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

..
Автор SHA1 Повідомлення Дата
l0ng-ai 0a03615988 feat(vcs): Deployment submenu in the changes tree's context menu
The Commit tool window's changes tree had no Deployment entries, so uploading changed
files meant finding them again in the Project view. Its context menu now takes other
features' groups through a new "changes" menu slot; Deployment contributes its submenu
there (Upload to, Download from, Sync with, Delete from Server, ...) for the selected
files that are still on disk.
2026-11-17 01:10:30 +08:00
635 змінених файлів з 1614 додано та 30826 видалено

No files matched your search

Створено
+44 -59
Переглянути файл
@@ -4144,7 +4144,7 @@ checksum = "3d3067d79b975e8844ca9eb072e16b31c3c1c36928edf9c6789548c524d0d954"
[[package]]
name = "ide-agent"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"blake3",
"dunce",
@@ -4169,7 +4169,7 @@ dependencies = [
[[package]]
name = "ide-analysis"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ast-grep-core",
"ide-core",
@@ -4183,7 +4183,7 @@ dependencies = [
[[package]]
name = "ide-android"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ide-core",
"serde",
@@ -4194,7 +4194,7 @@ dependencies = [
[[package]]
name = "ide-build"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"blake3",
"chardetng",
@@ -4212,7 +4212,7 @@ dependencies = [
[[package]]
name = "ide-cli"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"dirs 6.0.0",
"serde",
@@ -4226,7 +4226,7 @@ dependencies = [
[[package]]
name = "ide-clipboard"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"gtk",
"objc2 0.6.5",
@@ -4237,7 +4237,7 @@ dependencies = [
[[package]]
name = "ide-core"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"dunce",
"encoding_rs",
@@ -4254,7 +4254,7 @@ dependencies = [
[[package]]
name = "ide-coverage"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ide-core",
"ide-run",
@@ -4268,7 +4268,7 @@ dependencies = [
[[package]]
name = "ide-dap"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"base64 0.22.1",
"futures",
@@ -4297,7 +4297,7 @@ dependencies = [
[[package]]
name = "ide-db"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"base64 0.22.1",
"bb8",
@@ -4333,7 +4333,7 @@ dependencies = [
[[package]]
name = "ide-docker"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ide-core",
"serde",
@@ -4346,7 +4346,7 @@ dependencies = [
[[package]]
name = "ide-extension"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"base64 0.22.1",
"blake3",
@@ -4367,7 +4367,7 @@ dependencies = [
[[package]]
name = "ide-fonts"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"objc2-core-foundation",
"objc2-core-text",
@@ -4379,7 +4379,7 @@ dependencies = [
[[package]]
name = "ide-github"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ide-core",
"ide-vcs",
@@ -4392,7 +4392,7 @@ dependencies = [
[[package]]
name = "ide-heap"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"criterion",
"ide-core",
@@ -4410,7 +4410,7 @@ dependencies = [
[[package]]
name = "ide-host"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"base64 0.22.1",
"blake3",
@@ -4435,7 +4435,6 @@ dependencies = [
"ide-index",
"ide-jsonrpc",
"ide-jvm-attach",
"ide-jvm-inspect",
"ide-language",
"ide-lsp",
"ide-mcp",
@@ -4448,7 +4447,6 @@ dependencies = [
"ide-search",
"ide-spell",
"ide-ssh",
"ide-streams",
"ide-syntax",
"ide-terminal",
"ide-text",
@@ -4483,7 +4481,7 @@ dependencies = [
[[package]]
name = "ide-http"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ide-core",
"ide-vfs",
@@ -4502,7 +4500,7 @@ dependencies = [
[[package]]
name = "ide-index"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"blake3",
"criterion",
@@ -4524,7 +4522,7 @@ dependencies = [
[[package]]
name = "ide-jdwp"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ide-jvm-inspect",
"proptest",
@@ -4536,7 +4534,7 @@ dependencies = [
[[package]]
name = "ide-jsonrpc"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"encoding_rs",
"futures",
@@ -4553,7 +4551,7 @@ dependencies = [
[[package]]
name = "ide-jvm-attach"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"libc",
"tempfile",
@@ -4562,7 +4560,7 @@ dependencies = [
[[package]]
name = "ide-jvm-inspect"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"futures",
"serde",
@@ -4573,7 +4571,7 @@ dependencies = [
[[package]]
name = "ide-language"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"blake3",
"criterion",
@@ -4631,7 +4629,7 @@ dependencies = [
[[package]]
name = "ide-lsp"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"dunce",
"encoding_rs",
@@ -4659,7 +4657,7 @@ dependencies = [
[[package]]
name = "ide-mcp"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"bytes",
"dunce",
@@ -4678,7 +4676,7 @@ dependencies = [
[[package]]
name = "ide-notebook"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"futures",
"ide-core",
@@ -4701,7 +4699,7 @@ dependencies = [
[[package]]
name = "ide-plugin"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"blake3",
"dunce",
@@ -4724,7 +4722,7 @@ dependencies = [
[[package]]
name = "ide-profiler"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ide-core",
"ide-jvm-attach",
@@ -4738,7 +4736,7 @@ dependencies = [
[[package]]
name = "ide-remote"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"dunce",
"futures",
@@ -4758,7 +4756,7 @@ dependencies = [
[[package]]
name = "ide-run"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"dunce",
"encoding_rs",
@@ -4782,7 +4780,7 @@ dependencies = [
[[package]]
name = "ide-scaffold"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ide-core",
"ide-tools",
@@ -4798,7 +4796,7 @@ dependencies = [
[[package]]
name = "ide-sdk"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"dunce",
"flate2",
@@ -4821,7 +4819,7 @@ dependencies = [
[[package]]
name = "ide-search"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"criterion",
"encoding_rs",
@@ -4842,7 +4840,7 @@ dependencies = [
[[package]]
name = "ide-spell"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ide-core",
"parking_lot",
@@ -4855,7 +4853,7 @@ dependencies = [
[[package]]
name = "ide-ssh"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"dirs 6.0.0",
"flate2",
@@ -4878,22 +4876,9 @@ dependencies = [
"uuid",
]
[[package]]
name = "ide-streams"
version = "0.1.47"
dependencies = [
"ide-core",
"ide-language",
"ide-syntax",
"serde",
"serde_json",
"specta",
"tree-sitter",
]
[[package]]
name = "ide-syntax"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ide-core",
"ide-language",
@@ -4908,7 +4893,7 @@ dependencies = [
[[package]]
name = "ide-terminal"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"ide-core",
"libc",
@@ -4921,7 +4906,7 @@ dependencies = [
[[package]]
name = "ide-text"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"criterion",
"ide-core",
@@ -4934,7 +4919,7 @@ dependencies = [
[[package]]
name = "ide-tools"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"flate2",
"hex",
@@ -4955,7 +4940,7 @@ dependencies = [
[[package]]
name = "ide-vcs"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"blake3",
"dunce",
@@ -4976,7 +4961,7 @@ dependencies = [
[[package]]
name = "ide-vfs"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"chardetng",
"dunce",
@@ -5002,7 +4987,7 @@ dependencies = [
[[package]]
name = "ide-web"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"dirs 6.0.0",
"ide-core",
@@ -5018,7 +5003,7 @@ dependencies = [
[[package]]
name = "ide-workspace"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"blake3",
"dunce",
@@ -6647,7 +6632,7 @@ dependencies = [
[[package]]
name = "openidea"
version = "0.1.47"
version = "0.1.46"
dependencies = [
"base64 0.22.1",
"blake3",
+1 -2
Переглянути файл
@@ -5,7 +5,7 @@ members = ["crates/*", "src-tauri"]
exclude = ["sdk", "plugins"]
[workspace.package]
version = "0.1.47"
version = "0.1.46"
edition = "2024"
rust-version = "1.96"
license = "Apache-2.0"
@@ -52,7 +52,6 @@ ide-jvm-attach = { path = "crates/ide-jvm-attach" }
ide-jvm-inspect = { path = "crates/ide-jvm-inspect" }
ide-jdwp = { path = "crates/ide-jdwp" }
ide-heap = { path = "crates/ide-heap" }
ide-streams = { path = "crates/ide-streams" }
# serialization & IPC typing
serde = { version = "1", features = ["derive"] }
+23 -106
Переглянути файл
@@ -14,21 +14,20 @@ use std::collections::BTreeMap;
use std::sync::Arc;
use std::time::Duration;
const CONFIG_UPDATE_TIMEOUT: Duration = if cfg!(test) { Duration::from_millis(100) } else { Duration::from_secs(5) };
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.
pub(crate) async fn run(shared: &Arc<Shared>, spec: &ProviderSpec, model: Option<&str>) -> Result<Discovered, String> {
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, model).await {
match run_once(shared, spec, prefer_stored).await {
Err(err)
if !prefer_stored
&& crate::provider::is_copilot_provider(&spec.id)
&& crate::provider::has_unconfigured_copilot_ambient_token(&spec.env)
&& super::auth_required(0, &err) =>
{
let retry = run_once(shared, spec, true, model).await;
let retry = run_once(shared, spec, true).await;
if retry.is_ok() {
crate::provider::mark_prefer_stored_copilot_auth();
}
@@ -38,12 +37,7 @@ pub(crate) async fn run(shared: &Arc<Shared>, spec: &ProviderSpec, model: Option
}
}
async fn run_once(
shared: &Arc<Shared>,
spec: &ProviderSpec,
strip_ambient: bool,
selected_model: Option<&str>,
) -> Result<Discovered, String> {
async fn run_once(shared: &Arc<Shared>, spec: &ProviderSpec, strip_ambient: bool) -> Result<Discovered, String> {
let root = shared.paths.project_root.clone();
let launch = spec.clone();
let launch = tokio::task::spawn_blocking({
@@ -53,68 +47,28 @@ async fn run_once(
.await
.map_err(|e| e.to_string())?;
let cwd = dunce::canonicalize(&root).unwrap_or(root);
let updates = Arc::new(DiscoveryUpdates { provider: spec.id.clone(), ..Default::default() });
let updates = Arc::new(DiscoveryUpdates { provider: spec.id.clone(), commands: Mutex::new(None) });
let client = Dialect::wrap(updates.clone());
let on_stderr: Box<dyn Fn(String) + Send + Sync> = Box::new(|_| {});
let peer = (shared.connector)(&launch, &cwd, client.clone(), on_stderr)
.map_err(|e| format!("Couldn't start {} for model discovery: {e}", launch.name))?;
.map_err(|e| format!("Couldn't start {} (`{}`): {e}", launch.name, launch.command))?;
let _stop = crate::catalogs::KillPeer(peer.clone());
let conn = Conn::new(peer.clone(), client);
let work = async {
conn.initialize(&client_info()).await.map_err(discovery_error)?;
conn.initialize(&client_info()).await.map_err(|e| e.to_string())?;
let cwd_s = cwd.to_string_lossy().into_owned();
// No project MCP during discovery: Cursor can spend a long time spawning servers.
let new: Value = conn
.request("session/new", json!({ "cwd": cwd_s, "mcpServers": [] }), None)
.await
.map_err(discovery_error)?;
.map_err(|e| e.to_string())?;
let mut options = config::options_of(&new);
config::add_client_options(&launch.id, &mut options);
let model_option = options.iter().find(|o| o.category.as_deref() == Some("model"));
let mut levels = BTreeMap::new();
let has_config = new.get("configOptions").is_some_and(Value::is_array);
if has_config && let Some(model) = model_option.and_then(|o| o.current.as_ref()) {
levels.insert(model.clone(), levels_for_model_from_slice(&options));
}
if let Some(selected) = selected_model
&& let Some(option) = model_option.filter(|o| o.values.iter().any(|v| v.value == selected))
&& !levels.contains_key(selected)
{
let session =
new.get("sessionId").and_then(Value::as_str).ok_or("The agent did not return a session ID")?;
let (method, mut params) = config::set_request(option, selected);
params["sessionId"] = json!(session);
updates.config.lock().session = Some(session.to_owned());
let response: Value = conn.request(method, params, None).await.map_err(discovery_error)?;
let settings = if let Some(settings) = selected_settings(&response, selected) {
Some(settings)
} else {
tokio::time::timeout(CONFIG_UPDATE_TIMEOUT, async {
loop {
let notified = updates.changed.notified();
if let Some(settings) = updates
.config
.lock()
.options
.as_ref()
.and_then(|options| selected_settings(options, selected))
{
return settings;
}
notified.await;
}
})
.await
.ok()
};
match settings {
Some(settings) => levels.insert(selected.to_owned(), levels_for_model_from_slice(&settings)),
// An agent on the legacy `models` field that says nothing more: the model has
// no settings of its own, and switching to it must not fail.
None if !has_config => levels.insert(selected.to_owned(), Vec::new()),
None => return Err("The agent did not report settings for the selected model".to_owned()),
};
}
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 commands = updates
.commands
.lock()
@@ -134,38 +88,16 @@ async fn run_once(
struct DiscoveryUpdates {
provider: String,
commands: Mutex<Option<Vec<crate::AgentCommand>>>,
config: Mutex<DiscoveryConfig>,
changed: tokio::sync::Notify,
}
#[derive(Default)]
struct DiscoveryConfig {
session: Option<String>,
options: Option<Value>,
}
impl ide_jsonrpc::Handler for DiscoveryUpdates {
fn on_notification(&self, method: &str, params: Value) {
if method != "session/update" {
return;
}
let Some(update) = params.get("update") else { return };
match update["sessionUpdate"].as_str() {
Some("available_commands_update") => {
// Commands are protocol data, not stderr (which may contain credentials).
*self.commands.lock() = Some(config::commands_of(update, &self.provider));
}
Some("config_option_update") => {
let mut config = self.config.lock();
if config.session.as_deref() == params.get("sessionId").and_then(Value::as_str)
&& config.session.is_some()
&& update.get("configOptions").is_some_and(Value::is_array)
{
config.options = Some(update.clone());
self.changed.notify_one();
}
}
_ => {}
if method == "session/update"
&& let Some(update) = params.get("update")
&& update["sessionUpdate"] == "available_commands_update"
{
// Commands are protocol data, not stderr (which may contain credentials).
*self.commands.lock() = Some(config::commands_of(update, &self.provider));
}
}
@@ -174,24 +106,8 @@ impl ide_jsonrpc::Handler for DiscoveryUpdates {
}
}
fn discovery_error(error: ide_jsonrpc::RpcError) -> String {
match error {
ide_jsonrpc::RpcError::Server { code, message, .. } if super::auth_required(code, &message) => {
"Sign in required: the agent could not authenticate model discovery".into()
}
other => format!("The agent could not complete model discovery: {other}"),
}
}
fn selected_settings(response: &Value, model: &str) -> Option<Vec<AgentConfigOption>> {
response.get("configOptions")?.as_array()?;
let options = config::options_of(response);
let current = options.iter().find(|o| o.category.as_deref() == Some("model")).and_then(|o| o.current.as_deref());
current.is_none_or(|current| current == model).then_some(options)
}
fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Vec<AgentConfigOption> {
options
fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Option<Vec<AgentConfigOption>> {
let levels: Vec<_> = options
.iter()
.filter(|o| config::is_per_model_option(o))
.cloned()
@@ -205,5 +121,6 @@ fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Vec<AgentConfig
}
o
})
.collect()
.collect();
(!levels.is_empty()).then_some(levels)
}
+21 -138
Переглянути файл
@@ -45,18 +45,9 @@ struct Entry {
error: Option<String>,
flight: Option<watch::Receiver<bool>>,
abort: Option<tokio::task::AbortHandle>,
flight_model: Option<String>,
requested_model: Option<String>,
model_failures: HashMap<String, ModelFailure>,
catalog: Option<CatalogData>,
}
struct ModelFailure {
completed: Instant,
retry_at_ms: f64,
error: String,
}
#[derive(Clone, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub(crate) struct CatalogData {
@@ -213,24 +204,6 @@ impl AgentCatalogs {
.unwrap_or_else(|| Self::fallback(shared, provider))
}
pub(crate) fn levels(&self, shared: &Shared, provider: &str, model: &str) -> Option<Vec<AgentConfigOption>> {
let state = self.state.lock();
if let Some(catalog) = state.entries.get(&Self::key(shared, provider)).and_then(|entry| entry.catalog.as_ref())
{
return catalog.thought_levels.get(model).cloned();
}
drop(state);
let cache = shared.known.lock();
let known = cache.get(provider)?;
known
.catalogs
.get(&shared.root_key())
.map(|saved| &saved.catalog.thought_levels)
.unwrap_or(&known.thought_levels)
.get(model)
.cloned()
}
pub(crate) fn evict_if_idle(&self, shared: &Shared, provider: &str) {
let key = Self::key(shared, provider);
let mut state = self.state.lock();
@@ -241,27 +214,16 @@ impl AgentCatalogs {
fn snapshot(&self, shared: &Shared, provider: &str, entry: &Entry) -> AgentModelCatalog {
let catalog = entry.catalog.clone().unwrap_or_else(|| Self::fallback(shared, provider));
let model_failure = entry.requested_model.as_ref().and_then(|model| entry.model_failures.get(model));
let unknown_model = entry
.requested_model
.as_deref()
.is_some_and(|model| catalog.lists(model) && !catalog.thought_levels.contains_key(model));
AgentModelCatalog {
provider: provider.to_owned(),
config: shared.config_for_new_task(catalog.config, provider),
thought_levels: catalog.thought_levels,
refreshing: entry.flight.is_some(),
refreshed_at_ms: catalog.refreshed_at_ms,
retry_at_ms: model_failure
.filter(|failure| self.now().duration_since(failure.completed) < COOLDOWN)
.map(|failure| failure.retry_at_ms)
.or_else(|| {
(!unknown_model)
.then_some(entry.retry_at_ms)
.flatten()
.filter(|_| entry.completed.is_some_and(|at| self.now().duration_since(at) < COOLDOWN))
}),
error: model_failure.map(|failure| failure.error.clone()).or_else(|| entry.error.clone()),
retry_at_ms: entry
.retry_at_ms
.filter(|_| entry.completed.is_some_and(|at| self.now().duration_since(at) < COOLDOWN)),
error: entry.error.clone(),
}
}
@@ -271,7 +233,6 @@ impl AgentCatalogs {
shared: &Arc<Shared>,
spec: provider::ProviderSpec,
force: bool,
model: Option<&str>,
) -> (AgentModelCatalog, Option<watch::Receiver<bool>>) {
let key = Self::key(shared, &spec.id);
let context = LaunchContext::new(spec.clone(), &shared.paths.project_root);
@@ -303,7 +264,6 @@ impl AgentCatalogs {
let mut catalog = saved.catalog;
if !matching {
catalog.refreshed_at_ms = None;
catalog.thought_levels.clear();
}
catalog
});
@@ -319,73 +279,31 @@ impl AgentCatalogs {
error: None,
flight: None,
abort: None,
flight_model: None,
requested_model: None,
model_failures: HashMap::new(),
},
);
}
let fallback =
state.entries.get(&key).filter(|entry| entry.catalog.is_none()).map(|_| Self::fallback(shared, &spec.id));
state.generation += 1;
let generation = state.generation;
let entry = state.entries.get_mut(&key).expect("catalog entry");
let catalog = entry.catalog.as_ref().or(fallback.as_ref()).expect("cached catalog");
let cooling = entry.completed.is_some_and(|at| now.duration_since(at) < COOLDOWN);
let fresh = entry.successful.is_some_and(|at| now.duration_since(at) < FRESH_FOR);
let target = model
.filter(|model| {
(catalog.lists(model) && !catalog.thought_levels.contains_key(*model))
|| (!fresh && catalog.model_option().is_none())
})
.map(str::to_owned);
if model.is_some() && entry.requested_model.as_deref() != model {
entry.requested_model = model.map(str::to_owned);
}
let superseded = model.is_some()
&& entry.flight.is_some()
&& (entry.flight_model.is_some() || target.is_some())
&& entry.flight_model.as_deref() != target.as_deref();
if superseded {
if let Some(abort) = entry.abort.take() {
abort.abort();
}
entry.flight = None;
entry.generation = generation;
entry.flight_model = None;
}
let cooling = match target.as_ref() {
Some(model) => entry.model_failures.get(model).is_some_and(|f| now.duration_since(f.completed) < COOLDOWN),
None => entry.completed.is_some_and(|at| now.duration_since(at) < COOLDOWN),
};
let eligible = !cooling && (target.is_some() || force || !fresh);
let mut start = None;
if entry.flight.is_none() && eligible {
if entry.flight.is_none() && !cooling && (force || !fresh) {
let (done, ready) = watch::channel(false);
entry.flight = Some(ready);
entry.flight_model = target.clone();
entry.error = None;
if let Some(model) = target.as_ref() {
entry.model_failures.remove(model);
}
entry.retry_at_ms = None;
// Every flight has its own generation, including superseded model selections.
entry.generation = generation;
start = Some((entry.generation, target, done));
start = Some((entry.generation, done));
}
let snapshot = self.snapshot(shared, &spec.id, entry);
let flight = entry.flight.clone();
drop(state);
if superseded && start.is_none() {
self.broadcast(shared, &snapshot);
}
if let Some((generation, model, done)) = start {
if let Some((generation, done)) = start {
self.broadcast(shared, &snapshot);
let coordinator = self.clone();
let shared = shared.clone();
let flight_key = key.clone();
let task = shared.runtime.clone().spawn(async move {
let result = discover(&shared, spec, model.as_deref()).await;
coordinator.complete(&shared, flight_key, generation, model, result);
let result = discover(&shared, spec).await;
coordinator.complete(&shared, flight_key, generation, result);
let _ = done.send(true);
});
// A subscriber can re-enter and change configuration during the start event.
@@ -401,14 +319,7 @@ impl AgentCatalogs {
(snapshot, flight)
}
fn complete(
&self,
shared: &Shared,
key: Key,
generation: u64,
model: Option<String>,
result: Result<Discovered, String>,
) {
fn complete(&self, shared: &Shared, key: Key, generation: u64, result: Result<Discovered, String>) {
let current = provider::load(shared.paths.custom_agents_dir.as_deref(), shared.env_secrets())
.into_iter()
.find(|spec| spec.id == key.2)
@@ -419,7 +330,6 @@ impl AgentCatalogs {
if current.as_ref() != Some(&entry.context) {
entry.flight = None;
entry.abort = None;
entry.flight_model = None;
entry.completed = None;
entry.retry_at_ms = None;
entry.error = None;
@@ -430,16 +340,12 @@ impl AgentCatalogs {
return;
}
let now = self.now();
if model.is_none() {
entry.completed = Some(now);
entry.retry_at_ms = Some(self.epoch_ms() + COOLDOWN.as_millis() as f64);
}
entry.completed = Some(now);
entry.retry_at_ms = Some(self.epoch_ms() + COOLDOWN.as_millis() as f64);
entry.flight = None;
entry.abort = None;
entry.flight_model = None;
let success = match result {
Ok(found) => {
let previous = entry.catalog.take().unwrap_or_else(|| Self::fallback(shared, &key.2));
let mut cache = shared.known.lock();
let known = cache.entry(key.2.clone()).or_default();
let mut catalog = CatalogData {
@@ -448,7 +354,7 @@ impl AgentCatalogs {
refreshed_at_ms: Some(self.epoch_ms()),
};
// Efforts sessions reported for models discovery doesn't read stay while listed.
for (model, levels) in previous.thought_levels {
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);
}
@@ -467,30 +373,11 @@ impl AgentCatalogs {
entry.catalog = Some(catalog);
shared.persist_known(&cache);
entry.successful = Some(now);
entry.completed = Some(now);
entry.retry_at_ms = Some(self.epoch_ms() + COOLDOWN.as_millis() as f64);
entry.model_failures.retain(|model, _| {
entry
.catalog
.as_ref()
.is_some_and(|catalog| catalog.lists(model) && !catalog.thought_levels.contains_key(model))
});
entry.error = None;
true
}
Err(error) => {
if let Some(model) = model {
entry.model_failures.insert(
model,
ModelFailure {
completed: now,
retry_at_ms: self.epoch_ms() + COOLDOWN.as_millis() as f64,
error,
},
);
} else {
entry.error = Some(error);
}
entry.error = Some(error);
false
}
};
@@ -561,22 +448,18 @@ impl AgentCatalogs {
impl crate::AgentManager {
/// Return cached choices immediately and schedule discovery when eligible.
pub fn refresh_models(&self, provider: &str, force: bool, model: Option<&str>) -> IdeResult<AgentModelCatalog> {
pub fn refresh_models(&self, provider: &str, force: bool) -> IdeResult<AgentModelCatalog> {
// Settings and environment secrets can change while this window is open.
*self.shared.providers.write() =
provider::load(self.shared.paths.custom_agents_dir.as_deref(), self.shared.env_secrets());
let spec = self.shared.spec(provider).ok_or_else(|| IdeError::invalid(format!("unknown agent {provider}")))?;
Ok(self.shared.paths.catalogs.request(&self.shared, spec, force, model).0)
Ok(self.shared.paths.catalogs.request(&self.shared, spec, force).0)
}
}
async fn discover(
shared: &Arc<Shared>,
spec: provider::ProviderSpec,
model: Option<&str>,
) -> Result<Discovered, String> {
async fn discover(shared: &Arc<Shared>, spec: provider::ProviderSpec) -> Result<Discovered, String> {
match spec.driver {
provider::Driver::Acp => acp::discover::run(shared, &spec, model).await,
provider::Driver::Acp => acp::discover::run(shared, &spec).await,
provider::Driver::Codex => native::codex::discover(spec, shared.paths.project_root.clone()).await,
provider::Driver::Claude => {
let found = native::claude::discover(spec.clone(), shared.paths.project_root.clone()).await?;
@@ -601,7 +484,7 @@ async fn discover(
provider::Driver::Copilot => {
if shared.uses_copilot_acp_fallback(&spec) {
let acp_spec = native::copilot::acp_fallback_spec(&spec);
return acp::discover::run(shared, &acp_spec, model).await;
return acp::discover::run(shared, &acp_spec).await;
}
match native::copilot::discover(spec.clone(), shared.paths.project_root.clone()).await {
Ok(found) => Ok(Discovered {
@@ -630,7 +513,7 @@ async fn discover(
);
shared.mark_copilot_acp_fallback(&spec);
let acp_spec = native::copilot::acp_fallback_spec(&spec);
acp::discover::run(shared, &acp_spec, model).await
acp::discover::run(shared, &acp_spec).await
}
Err(err) => Err(err.message),
}
+56 -372
Переглянути файл
@@ -11,10 +11,8 @@ const PROVIDER: &str = "catalog-test";
#[derive(Debug)]
struct Pending {
method: String,
params: Value,
reply: oneshot::Sender<Result<Value, String>>,
notifications: mpsc::UnboundedSender<Value>,
}
struct Harness {
@@ -33,10 +31,6 @@ impl Drop for Live {
impl Harness {
fn new() -> Self {
Self::with_initialize(json!({ "protocolVersion": 1, "agentCapabilities": {}, "authMethods": [] }))
}
fn with_initialize(initialize: Value) -> Self {
let (pending_tx, pending) = mpsc::unbounded_channel();
let launches = Arc::new(AtomicUsize::new(0));
let live = Arc::new(AtomicUsize::new(0));
@@ -48,53 +42,26 @@ impl Harness {
live.fetch_add(1, Ordering::SeqCst);
let guard = Live(live.clone());
let pending = pending_tx.clone();
let initialize = initialize.clone();
let (notifications_tx, mut notifications) = mpsc::unbounded_channel::<Value>();
let (client_io, server_io) = tokio::io::duplex(1 << 16);
let (read, mut write) = tokio::io::split(server_io);
tokio::spawn(async move {
let _guard = guard;
let mut lines = BufReader::new(read).lines();
loop {
let line = tokio::select! {
line = lines.next_line() => match line.unwrap() {
Some(line) => line,
None => break,
},
Some(notification) = notifications.recv() => {
if write.write_all(format!("{notification}\n").as_bytes()).await.is_err() {
break;
}
continue;
}
};
while let Some(line) = lines.next_line().await.unwrap() {
let request: Value = serde_json::from_str(&line).unwrap();
let id = &request["id"];
if id.is_null() {
continue;
}
let response = match request["method"].as_str().unwrap() {
"initialize" => json!({ "id": id, "jsonrpc": "2.0", "result": initialize }),
"session/new" | "session/set_config_option" | "session/set_model" => {
let (reply, mut result) = oneshot::channel();
pending
.send(Pending {
method: request["method"].as_str().unwrap().to_owned(),
params: request["params"].clone(),
reply,
notifications: notifications_tx.clone(),
})
.unwrap();
let result = loop {
tokio::select! {
result = &mut result => break result.unwrap(),
_ = lines.next_line() => return,
Some(notification) = notifications.recv() => {
if write.write_all(format!("{notification}\n").as_bytes()).await.is_err() {
return;
}
}
}
"initialize" => json!({ "id": id, "jsonrpc": "2.0", "result": {
"protocolVersion": 1, "agentCapabilities": {}, "authMethods": [] } }),
"session/new" => {
let (reply, result) = oneshot::channel();
pending.send(Pending { params: request["params"].clone(), reply }).unwrap();
let result = tokio::select! {
result = result => result.unwrap(),
_ = lines.next_line() => break,
};
match result {
Ok(result) => json!({ "id": id, "jsonrpc": "2.0", "result": result }),
@@ -223,7 +190,7 @@ async fn successful_refresh_replaces_models_and_efforts_and_old_sessions_cannot_
let mut events = events(&manager);
let old = config::options_of(&response(&["old", "retained"], &["low", "high"]));
manager.shared.remember(PROVIDER, Some(&old), None, Some("old"));
let cached = manager.refresh_models(PROVIDER, false, None).unwrap();
let cached = manager.refresh_models(PROVIDER, false).unwrap();
assert!(cached.refreshing);
assert_eq!(model_values(&cached), ["old", "retained"]);
assert!(cached.refreshed_at_ms.is_none(), "session reports are not fresh discovery");
@@ -237,13 +204,13 @@ async fn successful_refresh_replaces_models_and_efforts_and_old_sessions_cannot_
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"));
assert_eq!(manager.refresh_models(PROVIDER, false, None).unwrap().config, fresh.config);
assert_eq!(manager.refresh_models(PROVIDER, false).unwrap().config, fresh.config);
let provider = manager.providers().into_iter().find(|p| p.id == PROVIDER).unwrap();
assert_eq!(provider.config, fresh.config);
let persisted = std::fs::read_to_string(tmp.path().join("models.json")).unwrap();
assert!(!persisted.contains("secret-one") && !persisted.contains("TOKEN"));
let restored = make_manager(tmp.path(), Arc::default(), &harness);
let restored_snapshot = restored.refresh_models(PROVIDER, false, None).unwrap();
let restored_snapshot = restored.refresh_models(PROVIDER, false).unwrap();
assert!(!restored_snapshot.refreshing, "matching persisted launch context remains fresh");
assert_eq!(restored_snapshot.refreshed_at_ms, fresh.refreshed_at_ms);
let provider = restored.providers().into_iter().find(|p| p.id == PROVIDER).unwrap();
@@ -262,7 +229,7 @@ async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() {
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, None).unwrap();
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
@@ -274,16 +241,16 @@ async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() {
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, None).unwrap();
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, None).unwrap();
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, None).unwrap();
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"]);
@@ -306,7 +273,7 @@ async fn legacy_cache_loads_without_claiming_authoritative_freshness() {
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), Arc::default(), &harness);
let mut events = events(&manager);
let cached = manager.refresh_models(PROVIDER, false, None).unwrap();
let cached = manager.refresh_models(PROVIDER, false).unwrap();
assert_eq!(model_values(&cached), ["legacy"]);
assert!(cached.refreshing && cached.refreshed_at_ms.is_none());
harness.next().await.reply.send(Err("Sign in required".into())).unwrap();
@@ -325,11 +292,11 @@ async fn concurrent_windows_commands_and_manual_requests_share_one_flight_and_co
let second = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut first_events = events(&first);
let mut second_events = events(&second);
assert!(first.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(first.refresh_models(PROVIDER, false).unwrap().refreshing);
let pending = harness.next().await;
for _ in 0..10 {
assert!(second.refresh_models(PROVIDER, true, None).unwrap().refreshing);
assert!(first.refresh_models(PROVIDER, true, None).unwrap().refreshing);
assert!(second.refresh_models(PROVIDER, true).unwrap().refreshing);
assert!(first.refresh_models(PROVIDER, true).unwrap().refreshing);
}
let commands = tokio::spawn({
let first = first.clone();
@@ -342,21 +309,21 @@ async fn concurrent_windows_commands_and_manual_requests_share_one_flight_and_co
assert_eq!(completed(&mut second_events).await, done);
commands.await.unwrap().unwrap();
for force in [false, true, false, true] {
assert!(!second.refresh_models(PROVIDER, force, None).unwrap().refreshing);
assert!(!second.refresh_models(PROVIDER, force).unwrap().refreshing);
}
advance(&catalogs, 29);
assert!(!first.refresh_models(PROVIDER, true, None).unwrap().refreshing);
assert!(!first.refresh_models(PROVIDER, true).unwrap().refreshing);
advance(&catalogs, 1);
assert!(!first.refresh_models(PROVIDER, false, None).unwrap().refreshing, "automatic refresh remains fresh");
assert!(first.refresh_models(PROVIDER, true, None).unwrap().refreshing);
assert!(!first.refresh_models(PROVIDER, false).unwrap().refreshing, "automatic refresh remains fresh");
assert!(first.refresh_models(PROVIDER, true).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&["two"], &["high"]))).unwrap();
let newer = completed(&mut first_events).await;
assert_eq!(model_values(&newer), ["two"]);
assert_eq!(completed(&mut second_events).await, newer);
advance(&catalogs, 15 * 60 - 1);
assert!(!second.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(!second.refresh_models(PROVIDER, false).unwrap().refreshing);
advance(&catalogs, 1);
assert!(second.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(second.refresh_models(PROVIDER, false).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&["three"], &["low"]))).unwrap();
completed(&mut first_events).await;
assert_eq!(harness.launches.load(Ordering::SeqCst), 3);
@@ -370,25 +337,25 @@ async fn failure_keeps_successful_choices_and_throttles_manual_and_auto_retries(
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, true, None).unwrap();
manager.refresh_models(PROVIDER, true).unwrap();
harness.next().await.reply.send(Ok(response(&["cached"], &["low"]))).unwrap();
let success = completed(&mut events).await;
let disk = std::fs::read(tmp.path().join("models.json")).unwrap();
advance(&catalogs, 15 * 60);
manager.refresh_models(PROVIDER, false, None).unwrap();
manager.refresh_models(PROVIDER, false).unwrap();
harness.next().await.reply.send(Err("Authentication expired".into())).unwrap();
let failed = completed(&mut events).await;
assert_eq!(failed.config, success.config);
assert_eq!(failed.thought_levels, success.thought_levels);
assert_eq!(failed.refreshed_at_ms, success.refreshed_at_ms);
assert!(failed.error.as_deref().unwrap().contains("Sign in required"));
assert!(failed.error.as_deref().unwrap().contains("Authentication expired"));
assert_eq!(std::fs::read(tmp.path().join("models.json")).unwrap(), disk);
assert!(!manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, false).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, true).unwrap().refreshing);
advance(&catalogs, 29);
assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, true).unwrap().refreshing);
advance(&catalogs, 1);
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(manager.refresh_models(PROVIDER, false).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&["recovered"], &["high"]))).unwrap();
let recovered = completed(&mut events).await;
assert_eq!(model_values(&recovered), ["recovered"]);
@@ -403,21 +370,21 @@ async fn timeout_cleans_up_and_enters_the_same_failure_cooldown() {
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, None).unwrap();
manager.refresh_models(PROVIDER, false).unwrap();
let pending = harness.next().await;
tokio::time::pause();
tokio::time::advance(Duration::from_secs(4)).await;
let failed = completed(&mut events).await;
assert!(failed.error.as_deref().unwrap().contains("time"));
assert!(failed.retry_at_ms.is_some());
assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, true).unwrap().refreshing);
assert!(!manager.refresh_models(PROVIDER, false).unwrap().refreshing);
tokio::time::resume();
stopped(&harness).await;
assert_eq!(harness.live.load(Ordering::SeqCst), 0, "timed-out connection must close");
assert!(pending.reply.is_closed());
advance(&catalogs, 30);
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(manager.refresh_models(PROVIDER, false).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&["retry"], &["low"]))).unwrap();
completed(&mut events).await;
}
@@ -431,16 +398,16 @@ async fn changed_effective_config_supersedes_old_completion_without_queueing() {
let first = make_manager(tmp.path(), catalogs.clone(), &harness);
let second = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&second);
first.refresh_models(PROVIDER, false, None).unwrap();
first.refresh_models(PROVIDER, false).unwrap();
let obsolete = harness.next().await;
configure(tmp.path(), "two");
assert!(second.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(second.refresh_models(PROVIDER, false).unwrap().refreshing);
let latest = harness.next().await;
latest.reply.send(Ok(response(&["latest"], &["high"]))).unwrap();
let fresh = completed(&mut events).await;
let _ = obsolete.reply.send(Ok(response(&["obsolete"], &["low"])));
stopped(&harness).await;
let shown = first.refresh_models(PROVIDER, false, None).unwrap();
let shown = first.refresh_models(PROVIDER, false).unwrap();
assert_eq!(shown.config, fresh.config);
assert_eq!(shown.refreshed_at_ms, fresh.refreshed_at_ms);
assert!(!shown.refreshing);
@@ -448,7 +415,7 @@ async fn changed_effective_config_supersedes_old_completion_without_queueing() {
assert!(!std::fs::read_to_string(tmp.path().join("models.json")).unwrap().contains("obsolete"));
// A changed configuration also invalidates successful freshness/cooldown.
configure(tmp.path(), "three");
assert!(first.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(first.refresh_models(PROVIDER, false).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&["new-config"], &["medium"]))).unwrap();
completed(&mut events).await;
}
@@ -458,7 +425,7 @@ async fn invalid_provider_is_a_request_error_and_does_not_launch() {
let tmp = tempfile::tempdir().unwrap();
let harness = Harness::new();
let manager = make_manager(tmp.path(), Arc::default(), &harness);
assert!(manager.refresh_models("missing-provider", true, None).is_err());
assert!(manager.refresh_models("missing-provider", true).is_err());
assert_eq!(harness.launches.load(Ordering::SeqCst), 0);
}
@@ -470,18 +437,18 @@ async fn replacing_the_executable_at_the_same_path_invalidates_freshness_and_obs
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), catalogs, &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, None).unwrap();
manager.refresh_models(PROVIDER, false).unwrap();
let obsolete = harness.next().await;
std::fs::write(tmp.path().join("catalog-test-bin"), "replacement executable with different size").unwrap();
manager.refresh_models(PROVIDER, false, None).unwrap();
manager.refresh_models(PROVIDER, false).unwrap();
let latest = harness.next().await;
latest.reply.send(Ok(response(&["updated"], &["high"]))).unwrap();
let fresh = completed(&mut events).await;
let _ = obsolete.reply.send(Ok(response(&["obsolete"], &["low"])));
stopped(&harness).await;
assert_eq!(manager.refresh_models(PROVIDER, false, None).unwrap().config, fresh.config);
assert_eq!(manager.refresh_models(PROVIDER, false).unwrap().config, fresh.config);
std::fs::write(tmp.path().join("catalog-test-bin"), "another executable").unwrap();
assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing);
assert!(manager.refresh_models(PROVIDER, false).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&["new-install"], &["medium"]))).unwrap();
assert_eq!(model_values(&completed(&mut events).await), ["new-install"]);
assert_eq!(harness.launches.load(Ordering::SeqCst), 3);
@@ -501,18 +468,18 @@ async fn project_catalogs_and_persisted_freshness_do_not_leak_between_contexts()
let second = make_manager_at(&b, &models_file, catalogs, &harness);
let mut first_events = events(&first);
let mut second_events = events(&second);
first.refresh_models(PROVIDER, false, None).unwrap();
first.refresh_models(PROVIDER, false).unwrap();
harness.next().await.reply.send(Ok(response(&["account-a-model"], &["low"]))).unwrap();
let a_catalog = completed(&mut first_events).await;
second.refresh_models(PROVIDER, false, None).unwrap();
second.refresh_models(PROVIDER, false).unwrap();
harness.next().await.reply.send(Ok(response(&["account-b-model"], &["high"]))).unwrap();
let b_catalog = completed(&mut second_events).await;
assert_eq!(first.refresh_models(PROVIDER, false, None).unwrap().config, a_catalog.config);
assert_eq!(second.refresh_models(PROVIDER, false, None).unwrap().config, b_catalog.config);
assert_eq!(first.refresh_models(PROVIDER, false).unwrap().config, a_catalog.config);
assert_eq!(second.refresh_models(PROVIDER, false).unwrap().config, b_catalog.config);
assert_eq!(first.providers().into_iter().find(|p| p.id == PROVIDER).unwrap().config, a_catalog.config);
for (root, expected) in [(&a, &a_catalog), (&b, &b_catalog)] {
let restored = make_manager_at(root, &models_file, Arc::default(), &harness);
let cached = restored.refresh_models(PROVIDER, false, None).unwrap();
let cached = restored.refresh_models(PROVIDER, false).unwrap();
assert!(!cached.refreshing, "matching persisted context should retain freshness");
assert_eq!(cached.config, expected.config);
assert_eq!(cached.refreshed_at_ms, expected.refreshed_at_ms);
@@ -521,7 +488,7 @@ async fn project_catalogs_and_persisted_freshness_do_not_leak_between_contexts()
configure(&a, "new-account");
let changed = make_manager_at(&a, &models_file, Arc::default(), &harness);
let mut events = events(&changed);
let stale = changed.refresh_models(PROVIDER, false, None).unwrap();
let stale = changed.refresh_models(PROVIDER, false).unwrap();
assert!(stale.refreshing, "a different launch environment cannot reuse persisted freshness");
assert!(stale.refreshed_at_ms.is_none());
assert_eq!(stale.config, a_catalog.config, "stale cached choices remain selectable");
@@ -538,7 +505,7 @@ async fn configuration_changed_without_another_request_also_discards_old_discove
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), Arc::default(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, None).unwrap();
manager.refresh_models(PROVIDER, false).unwrap();
let obsolete = harness.next().await;
configure(tmp.path(), "after");
obsolete.reply.send(Ok(response(&["obsolete"], &["low"]))).unwrap();
@@ -546,7 +513,7 @@ async fn configuration_changed_without_another_request_also_discards_old_discove
assert!(model_values(&discarded).is_empty());
assert!(discarded.refreshed_at_ms.is_none());
assert!(!tmp.path().join("models.json").exists());
manager.refresh_models(PROVIDER, false, None).unwrap();
manager.refresh_models(PROVIDER, false).unwrap();
harness.next().await.reply.send(Ok(response(&["current"], &["high"]))).unwrap();
assert_eq!(model_values(&completed(&mut events).await), ["current"]);
}
@@ -559,296 +526,13 @@ async fn successful_empty_catalog_removes_all_previous_models_and_efforts() {
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, true, None).unwrap();
manager.refresh_models(PROVIDER, true).unwrap();
harness.next().await.reply.send(Ok(response(&["removed"], &["low"]))).unwrap();
completed(&mut events).await;
advance(&catalogs, 30);
manager.refresh_models(PROVIDER, true, None).unwrap();
manager.refresh_models(PROVIDER, true).unwrap();
harness.next().await.reply.send(Ok(response(&[], &[]))).unwrap();
let empty = completed(&mut events).await;
assert!(model_values(&empty).is_empty() && empty.thought_levels.is_empty());
assert!(empty.refreshed_at_ms.is_some() && empty.error.is_none());
}
fn selected_response(model: &str, effort: &[&str]) -> Value {
let mut result = response(&[model], effort);
if effort.is_empty() {
result["configOptions"].as_array_mut().unwrap().retain(|option| option["id"] != "effort");
}
result
}
fn config_notification(session: &str, result: &Value) -> Value {
json!({ "jsonrpc": "2.0", "method": "session/update", "params": {
"sessionId": session,
"update": { "sessionUpdate": "config_option_update", "configOptions": result["configOptions"] }
} })
}
fn efforts<'a>(catalog: &'a AgentModelCatalog, model: &str) -> Vec<&'a str> {
catalog.thought_levels[model]
.iter()
.filter(|option| option.category.as_deref() == Some("thought_level"))
.flat_map(|option| option.values.iter().map(|value| value.value.as_str()))
.collect()
}
#[tokio::test]
async fn selected_models_report_their_own_controls_before_any_task_or_prompt() {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let catalogs = Arc::new(AgentCatalogs::default());
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, None).unwrap();
let models = ["default", "second", "plain", "unknown"];
harness.next().await.reply.send(Ok(response(&models, &["low", "high"]))).unwrap();
let original = completed(&mut events).await;
assert!(!original.thought_levels.contains_key("second"));
// A fresh catalog and its global cooldown must not delay an unknown selection.
assert!(manager.refresh_models(PROVIDER, false, Some("second")).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&models, &["low", "high"]))).unwrap();
let pending = harness.next().await;
assert_eq!(pending.method, "session/set_config_option");
assert_eq!(pending.params, json!({ "sessionId": "discovery-only", "configId": "model", "value": "second" }));
let mut second = selected_response("second", &["off", "auto", "max"]);
second["configOptions"].as_array_mut().unwrap().push(json!({
"id": "context_tier", "type": "select", "currentValue": "large",
"options": [{ "value": "normal" }, { "value": "large" }]
}));
pending.reply.send(Ok(second)).unwrap();
let learned = completed(&mut events).await;
assert_eq!(learned.config, original.config, "selection discovery never changes the default model");
assert_eq!(efforts(&learned, "default"), ["low", "high"]);
assert_eq!(efforts(&learned, "second"), ["off", "auto", "max"]);
assert!(learned.thought_levels["second"].iter().any(|option| option.id == "context_tier"));
assert!(!learned.thought_levels.contains_key("unknown"));
manager.refresh_models(PROVIDER, false, Some("plain")).unwrap();
harness.next().await.reply.send(Ok(response(&models, &["low", "high"]))).unwrap();
harness.next().await.reply.send(Ok(selected_response("plain", &[]))).unwrap();
let plain = completed(&mut events).await;
assert!(plain.thought_levels["plain"].is_empty(), "an authoritative no-control result is cached");
for model in ["default", "second", "plain"] {
assert!(!manager.refresh_models(PROVIDER, false, Some(model)).unwrap().refreshing);
}
let restored = make_manager(tmp.path(), Arc::default(), &harness);
let cached = restored.refresh_models(PROVIDER, false, Some("plain")).unwrap();
assert!(!cached.refreshing);
assert!(cached.thought_levels["plain"].is_empty());
assert_eq!(efforts(&cached, "second"), ["off", "auto", "max"]);
assert_eq!(harness.launches.load(Ordering::SeqCst), 3, "never iterate unselected models");
assert!(!tmp.path().join("store").exists(), "no task or prompt is needed");
}
#[tokio::test]
async fn missing_or_failed_selected_settings_remain_unknown_and_have_model_scoped_retry_cooldowns() {
for reply in [Ok(json!({})), Ok(selected_response("default", &["wrong"])), Err("token=secret-one".into())] {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let catalogs = Arc::new(AgentCatalogs::default());
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&manager);
let models = ["default", "unsupported", "other"];
manager.refresh_models(PROVIDER, false, None).unwrap();
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
let original = completed(&mut events).await;
manager.refresh_models(PROVIDER, false, Some("unsupported")).unwrap();
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
harness.next().await.reply.send(reply).unwrap();
let failed = completed(&mut events).await;
assert_eq!(failed.config, original.config);
assert!(!failed.thought_levels.contains_key("unsupported"));
assert!(failed.error.is_some() && failed.retry_at_ms.is_some());
assert!(!failed.error.as_deref().unwrap().contains("secret-one"));
assert!(!manager.refresh_models(PROVIDER, true, Some("unsupported")).unwrap().refreshing);
// The failed model cannot block another model, and its cooldown survives that success.
assert!(manager.refresh_models(PROVIDER, false, Some("other")).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
harness.next().await.reply.send(Ok(selected_response("other", &[]))).unwrap();
assert!(completed(&mut events).await.error.is_none());
assert!(!manager.refresh_models(PROVIDER, false, Some("unsupported")).unwrap().refreshing);
advance(&catalogs, 30);
assert!(manager.refresh_models(PROVIDER, true, Some("unsupported")).unwrap().refreshing);
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
harness.next().await.reply.send(Ok(selected_response("unsupported", &["high"]))).unwrap();
let retried = completed(&mut events).await;
assert_eq!(efforts(&retried, "unsupported"), ["high"]);
assert!(retried.error.is_none());
}
}
#[tokio::test]
async fn rapid_model_selections_share_the_current_flight_and_discard_superseded_results() {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let catalogs = Arc::new(AgentCatalogs::default());
let mut harness = Harness::new();
let first = make_manager(tmp.path(), catalogs.clone(), &harness);
let second = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&first);
let models = ["default", "second", "third"];
first.refresh_models(PROVIDER, false, None).unwrap();
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
completed(&mut events).await;
first.refresh_models(PROVIDER, false, Some("second")).unwrap();
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
let obsolete = harness.next().await;
for _ in 0..5 {
assert!(second.refresh_models(PROVIDER, false, Some("second")).unwrap().refreshing);
}
assert_eq!(harness.launches.load(Ordering::SeqCst), 2);
second.refresh_models(PROVIDER, false, Some("third")).unwrap();
harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap();
let current = harness.next().await;
assert_eq!(current.params["value"], "third");
current.reply.send(Ok(selected_response("third", &["max"]))).unwrap();
let fresh = completed(&mut events).await;
let _ = obsolete.reply.send(Ok(selected_response("second", &["obsolete"])));
stopped(&harness).await;
let cached = first.refresh_models(PROVIDER, false, Some("third")).unwrap();
assert_eq!(cached, fresh);
assert_eq!(efforts(&cached, "third"), ["max"]);
assert!(!cached.thought_levels.contains_key("second"));
assert_eq!(harness.launches.load(Ordering::SeqCst), 3, "no stale requests are queued");
assert!(!std::fs::read_to_string(tmp.path().join("models.json")).unwrap().contains("obsolete"));
}
#[tokio::test]
async fn switching_back_to_a_known_model_cancels_the_unknown_model_flight() {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), Arc::default(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, None).unwrap();
harness.next().await.reply.send(Ok(response(&["default", "second"], &["low"]))).unwrap();
completed(&mut events).await;
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
let obsolete = harness.next().await;
let known = manager.refresh_models(PROVIDER, false, Some("default")).unwrap();
assert!(!known.refreshing);
assert_eq!(completed(&mut events).await, known, "other subscribers also leave loading state");
let _ = obsolete.reply.send(Err("late failure".into()));
stopped(&harness).await;
let cached = manager.refresh_models(PROVIDER, false, Some("default")).unwrap();
assert!(cached.error.is_none() && !cached.thought_levels.contains_key("second"));
assert_eq!(harness.launches.load(Ordering::SeqCst), 2);
}
#[tokio::test]
async fn selected_model_uses_legacy_set_model_and_authoritative_notifications() {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), Arc::default(), &harness);
let mut events = events(&manager);
// No cache is needed: the selected model is resolved in the same short-lived session.
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
harness
.next()
.await
.reply
.send(Ok(json!({
"sessionId": "discovery-only",
"models": { "currentModelId": "default", "availableModels": [
{ "modelId": "default", "name": "Default" }, { "modelId": "second", "name": "Second" }
] }
})))
.unwrap();
let selected = harness.next().await;
assert_eq!(selected.method, "session/set_model");
assert_eq!(selected.params, json!({ "sessionId": "discovery-only", "modelId": "second" }));
let notifications = selected.notifications;
selected.reply.send(Ok(json!({}))).unwrap();
notifications.send(config_notification("different-session", &selected_response("second", &["wrong"]))).unwrap();
notifications
.send(config_notification("discovery-only", &selected_response("second", &["medium", "high"])))
.unwrap();
let catalog = completed(&mut events).await;
assert_eq!(efforts(&catalog, "second"), ["medium", "high"]);
assert_eq!(catalog.config.iter().find(|option| option.id == "model").unwrap().current.as_deref(), Some("default"));
assert!(!catalog.thought_levels.contains_key("default"), "legacy model lists alone do not assert no controls");
}
#[tokio::test]
async fn selected_legacy_model_without_settings_has_no_levels_instead_of_failing() {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), Arc::default(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
harness
.next()
.await
.reply
.send(Ok(json!({
"sessionId": "discovery-only",
"models": { "currentModelId": "default", "availableModels": [
{ "modelId": "default", "name": "Default" }, { "modelId": "second", "name": "Second" }
] }
})))
.unwrap();
let selected = harness.next().await;
assert_eq!(selected.method, "session/set_model");
selected.reply.send(Ok(json!({}))).unwrap();
let catalog = completed(&mut events).await;
assert!(catalog.error.is_none(), "{:?}", catalog.error);
assert_eq!(catalog.thought_levels.get("second"), Some(&Vec::new()));
}
#[tokio::test]
async fn catalog_replacement_removes_selected_metadata_for_models_no_longer_listed() {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let catalogs = Arc::new(AgentCatalogs::default());
let mut harness = Harness::new();
let manager = make_manager(tmp.path(), catalogs.clone(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
harness.next().await.reply.send(Ok(response(&["default", "second"], &["low"]))).unwrap();
harness.next().await.reply.send(Ok(selected_response("second", &["max"]))).unwrap();
completed(&mut events).await;
advance(&catalogs, 30);
manager.refresh_models(PROVIDER, true, None).unwrap();
harness.next().await.reply.send(Ok(response(&["default", "new"], &["medium"]))).unwrap();
let replaced = completed(&mut events).await;
assert_eq!(model_values(&replaced), ["default", "new"]);
assert_eq!(efforts(&replaced, "default"), ["medium"]);
assert!(!replaced.thought_levels.contains_key("second") && !replaced.thought_levels.contains_key("new"));
}
#[tokio::test]
async fn selected_model_discovery_uses_the_negotiated_v2_wire_format_and_config_updates() {
let tmp = tempfile::tempdir().unwrap();
configure(tmp.path(), "one");
let mut harness = Harness::with_initialize(json!({
"protocolVersion": 2, "info": { "name": "V2 Catalog Test" }, "capabilities": { "session": {} }
}));
let manager = make_manager(tmp.path(), Arc::default(), &harness);
let mut events = events(&manager);
manager.refresh_models(PROVIDER, false, Some("second")).unwrap();
let mut initial = response(&["default", "second"], &["low"]);
for option in initial["configOptions"].as_array_mut().unwrap() {
option["configId"] = option.as_object_mut().unwrap().remove("id").unwrap();
}
harness.next().await.reply.send(Ok(initial)).unwrap();
let selected = harness.next().await;
assert_eq!(selected.method, "session/set_config_option");
assert_eq!(
selected.params,
json!({
"sessionId": "discovery-only", "configId": "model", "value": "second", "type": "id"
})
);
// Notifications may arrive before the request response as well as after it.
selected.notifications.send(config_notification("discovery-only", &selected_response("second", &[]))).unwrap();
selected.reply.send(Ok(json!({}))).unwrap();
let catalog = completed(&mut events).await;
assert!(catalog.thought_levels["second"].is_empty());
assert_eq!(efforts(&catalog, "default"), ["low"]);
}
+24 -104
Переглянути файл
@@ -363,7 +363,6 @@ struct TaskState {
session_id: Option<String>,
conversation: Conversation,
wanted: Vec<AgentConfigChoice>,
model_choice: u64,
before: Arc<BTreeMap<String, worktree::Stamp>>,
saved: Option<String>,
/// See `TaskFile::touched`.
@@ -622,7 +621,7 @@ impl AgentManager {
.into_iter()
.find(|spec| spec.id == provider)
{
let (_, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false, None);
let (_, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false);
if let Some(mut ready) = flight {
while !*ready.borrow_and_update() {
if ready.changed().await.is_err() {
@@ -955,36 +954,19 @@ impl AgentManager {
/// Changes a session setting (model, mode…): right away when the agent runs, else when it next starts.
pub async fn set_config(&self, id: &str, option: &str, value: String) -> IdeResult<()> {
let task = self.task(id)?;
let (target, model_choice, previous_levels) = {
let mut s = task.state.lock();
let target = s
.task
.config
.iter()
.find(|o| o.id == option)
.ok_or_else(|| IdeError::not_found("no such setting"))?
.clone();
if !target.values.iter().any(|v| v.value == value) {
return Err(IdeError::invalid(format!("{} has no value {value}", target.name)));
let target = {
let s = task.state.lock();
let o =
s.task.config.iter().find(|o| o.id == option).ok_or_else(|| IdeError::not_found("no such setting"))?;
if !o.values.iter().any(|v| v.value == value) {
return Err(IdeError::invalid(format!("{} has no value {value}", o.name)));
}
if target.category.as_deref() == Some("model") {
s.model_choice += 1;
}
let previous_levels =
if target.category.as_deref() == Some("model") && target.current.as_deref() != Some(value.as_str()) {
Some(s.task.config.extract_if(.., |o| config::is_per_model_option(o)).collect::<Vec<_>>())
} else {
None
};
s.wanted.retain(|c| c.id != option);
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: value.clone() });
s.task.config.iter_mut().find(|o| o.id == option).expect("selected setting").current = Some(value.clone());
s.task.model = model_of(&s.task.config).or(s.task.model.take());
(target, s.model_choice, previous_levels)
o.clone()
};
let previous = target.current.clone();
// Cursor's `session/set_config_option` (Fast, effort) can take seconds. Show the
// choice first so the switch and slider move immediately.
apply_config_choice(&task, option, &value);
task.persist();
task.emit_task();
@@ -994,77 +976,36 @@ impl AgentManager {
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);
if live.is_none()
&& target.category.as_deref() == Some("model")
&& (previous.as_deref() != Some(value.as_str()) || !model_options)
{
let provider = task.state.lock().task.provider.clone();
let mut levels = self.shared.paths.catalogs.levels(&self.shared, &provider, &value);
let mut error = None;
if levels.is_none()
&& let Some(spec) = self.shared.spec(&provider)
{
let (catalog, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false, Some(&value));
error = catalog.error;
if let Some(mut ready) = flight {
while !*ready.borrow_and_update() {
if ready.changed().await.is_err() {
break;
}
}
}
levels = self.shared.paths.catalogs.levels(&self.shared, &provider, &value);
}
// Another selection may have superseded this discovery while it was waiting.
if task.state.lock().model_choice != model_choice {
return Ok(());
}
let Some(levels) = levels else {
restore_config_choice(&task, &target, &value, previous.as_deref(), model_choice, previous_levels);
task.persist();
task.emit_task();
return Err(IdeError::unavailable(
error.unwrap_or_else(|| "The agent did not report settings for the selected model".into()),
));
};
let mut s = task.state.lock();
if s.model_choice != model_choice {
return Ok(());
}
s.task.config.retain(|o| !config::is_per_model_option(o));
s.task.config.extend(levels);
model_options = true;
}
if let Some(live) = live.filter(|_| option != config::CURSOR_APPROVAL) {
let (method, mut params) = config::set_request(&target, &value);
params["sessionId"] = json!(live.session);
let reply: Value = match live.peer.request(method, params, None).await {
Ok(reply) => reply,
Err(e) => {
restore_config_choice(&task, &target, &value, previous.as_deref(), model_choice, previous_levels);
{
let mut s = task.state.lock();
s.wanted.retain(|c| c.id != option);
if let Some(prev) = previous.clone() {
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: prev });
}
if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option) {
o.current = previous.clone();
}
s.task.model = model_of(&s.task.config).or(s.task.model.take());
}
task.persist();
task.emit_task();
return Err(IdeError::internal(task.describe(e)));
}
};
if target.category.as_deref() == Some("model") && task.state.lock().model_choice != model_choice {
return Ok(());
}
if let Some(options) = reply.get("configOptions") {
config::merge_update(&mut task.state.lock().task.config, options);
model_options = true;
} else if target.category.as_deref() == Some("model") {
// Old model controls were removed above, so these came from an update
// that preceded the response.
model_options = task.state.lock().task.config.iter().any(config::is_per_model_option);
}
}
{
let mut s = task.state.lock();
if target.category.as_deref() == Some("model") && s.model_choice != model_choice {
return Ok(());
}
if !model_options && target.category.as_deref() == Some("model") {
if !model_options {
s.task.config.retain(|o| !config::is_per_model_option(o));
}
if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option) {
@@ -1642,7 +1583,6 @@ impl Task {
session_id: file.session_id,
conversation,
wanted: file.wanted,
model_choice: 0,
before: Arc::new(file.before),
saved: file.saved,
touched: file.touched.map(Arc::new),
@@ -3153,32 +3093,12 @@ fn retry_of(update: &Value, now: f64) -> Option<AgentRetry> {
})
}
fn restore_config_choice(
task: &Task,
target: &AgentConfigOption,
value: &str,
previous: Option<&str>,
model_choice: u64,
previous_levels: Option<Vec<AgentConfigOption>>,
) {
let option = target.id.as_str();
let is_model = target.category.as_deref() == Some("model");
fn apply_config_choice(task: &Task, option: &str, value: &str) {
let mut s = task.state.lock();
if (is_model && s.model_choice != model_choice)
|| !s.task.config.iter().any(|o| o.id == option && o.current.as_deref() == Some(value))
{
return;
}
s.wanted.retain(|c| c.id != option);
if let Some(previous) = previous {
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: previous.to_owned() });
}
s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: value.to_owned() });
if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option) {
o.current = previous.map(str::to_owned);
}
if let Some(levels) = previous_levels {
s.task.config.retain(|o| !config::is_per_model_option(o));
s.task.config.extend(levels);
o.current = Some(value.to_owned());
}
s.task.model = model_of(&s.task.config).or(s.task.model.take());
}
+5 -159
Переглянути файл
@@ -51,7 +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>>>,
model_config_gate: Mutex<Option<std::sync::mpsc::Receiver<()>>>,
/// Advertises steering as OMP does (`_meta.steering` at the top of `initialize`)
/// instead of `_meta.openidea.steer`.
session_steering: bool,
@@ -232,12 +231,6 @@ impl Handler for FakeAgent {
std::thread::sleep(self.delay_config);
}
self.calls.lock().push(format!("{method} {}", params.get("value").or(params.get("modeId")).unwrap()));
if params["configId"] == "model" {
let gate = self.model_config_gate.lock().take();
if let Some(gate) = gate {
gate.recv().unwrap();
}
}
if params["configId"] == "model" && !self.model_options.lock().is_empty() {
return Ok(json!({"configOptions": self.options_for(params["value"].as_str().unwrap())}));
}
@@ -597,7 +590,6 @@ for line in sys.stdin:
assert_eq!(names, ["compact", "clear", "model", "context", "triage"]);
assert_eq!(first[0].hint.as_deref(), Some("[instructions]"));
let restored = manager(root, Arc::new(FakeAgent::default()));
restored.set_builtin_command("claude", Some(script.to_string_lossy().into_owned())).unwrap();
assert_eq!(first, restored.commands("claude", None).await.unwrap());
// The same handshake lists the models, so the composer has them before any task.
for mgr in [&mgr, &restored] {
@@ -1939,7 +1931,8 @@ async fn thinking_levels_are_remembered_per_provider_and_model() {
#[tokio::test(flavor = "multi_thread")]
async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() {
// Idle selections use cached model controls or discover them before the next prompt.
// 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());
@@ -1952,7 +1945,7 @@ async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() {
.create(NewAgentTask {
project_root: None,
prompt: text("again"),
provider: "claude-acp".into(),
provider: "claude".into(),
config: vec![],
isolation: Isolation::Local,
base: None,
@@ -1964,165 +1957,18 @@ async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() {
mgr.shutdown();
let restored = manager(tmp.path(), agent);
restored.set_config(&task.id, "model", "small".into()).await.unwrap();
{
let small = restored.task(&task.id).unwrap();
let small = small.state.lock();
let effort = small.task.config.iter().find(|option| option.id == "effort").unwrap();
assert_eq!(
effort.values.iter().map(|value| value.value.as_str()).collect::<Vec<_>>(),
["minimal", "medium"]
);
}
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-acp").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-acp"].thought_levels, p.thought_levels, "{option}");
assert_eq!(saved["claude"].thought_levels, p.thought_levels, "{option}");
restored.shutdown();
}
}
#[tokio::test(flavor = "multi_thread")]
async fn idle_model_switches_discover_controls_and_no_control_models_without_another_prompt() {
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")),
("plain".into(), vec![]),
]);
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
prompt: text("again"),
provider: "claude-acp".into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
mgr.shutdown();
let restored = manager(tmp.path(), agent.clone());
assert!(
!restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp").thought_levels.contains_key("small")
);
agent.calls.lock().clear();
restored.set_config(&task.id, "model", "small".into()).await.unwrap();
let current = restored.task(&task.id).unwrap();
let config = current.state.lock().task.config.clone();
let effort = config.iter().find(|option| option.id == "effort").unwrap();
assert_eq!(effort.values.iter().map(|value| value.value.as_str()).collect::<Vec<_>>(), ["minimal", "medium"]);
restored.set_config(&task.id, "effort", "medium".into()).await.unwrap();
restored.set_config(&task.id, "model", "plain".into()).await.unwrap();
assert!(!current.state.lock().task.config.iter().any(config::is_per_model_option));
let known = restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp");
assert!(known.thought_levels["plain"].is_empty());
assert_eq!(known.config.iter().find(|option| option.id == "model").unwrap().current.as_deref(), Some("big"));
{
let mut calls = agent.calls.lock();
assert!(!calls.iter().any(|call| call == "session/prompt" || call == "session/load"));
assert_eq!(calls.iter().filter(|call| *call == "session/new").count(), 2);
calls.clear();
}
restored.set_config(&task.id, "model", "small".into()).await.unwrap();
assert!(agent.calls.lock().is_empty(), "a known model remains a cache-only selection");
assert!(current.live.lock().is_none(), "discovery never mutates a task's live session");
restored.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn idle_model_discovery_failure_restores_the_previous_choice_without_claiming_no_controls() {
let tmp = tempfile::tempdir().unwrap();
let agent = Arc::new(FakeAgent::default());
*agent.extra_options.lock() = effort_options(&["low", "high"], "low");
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
prompt: text("again"),
provider: "claude-acp".into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
mgr.shutdown();
let restored = manager(tmp.path(), agent.clone());
agent.calls.lock().clear();
assert!(restored.set_config(&task.id, "model", "small".into()).await.is_err());
let current = restored.task(&task.id).unwrap();
assert_eq!(current.state.lock().task.model.as_deref(), Some("big"));
assert!(current.state.lock().task.config.iter().any(|option| option.id == "effort"));
assert!(
!restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp").thought_levels.contains_key("small")
);
assert!(!agent.calls.lock().iter().any(|call| call == "session/prompt"));
restored.shutdown();
}
#[tokio::test(flavor = "multi_thread")]
async fn rapid_idle_model_switches_share_discovery_and_never_apply_a_stale_completion() {
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")),
("plain".into(), vec![]),
]);
let mgr = manager(tmp.path(), agent.clone());
let task = mgr
.create(NewAgentTask {
prompt: text("again"),
provider: "claude-acp".into(),
isolation: Isolation::Local,
..Default::default()
})
.await
.unwrap();
wait_for(&mgr, &task.id, AgentStatus::Ready).await;
mgr.shutdown();
let restored = Arc::new(manager(tmp.path(), agent.clone()));
agent.calls.lock().clear();
let (release, gate) = std::sync::mpsc::channel();
*agent.model_config_gate.lock() = Some(gate);
let first = tokio::spawn({
let restored = restored.clone();
let id = task.id.clone();
async move { restored.set_config(&id, "model", "small".into()).await }
});
tokio::time::timeout(Duration::from_secs(5), async {
while agent.model_config_gate.lock().is_some() {
tokio::task::yield_now().await;
}
})
.await
.unwrap();
let duplicate = restored.set_config(&task.id, "model", "small".into());
tokio::pin!(duplicate);
tokio::select! {
biased;
result = &mut duplicate => panic!("duplicate selection must join the pending discovery: {result:?}"),
_ = tokio::task::yield_now() => {}
}
restored.set_config(&task.id, "model", "plain".into()).await.unwrap();
release.send(()).unwrap();
first.await.unwrap().unwrap();
duplicate.await.unwrap();
let current = restored.task(&task.id).unwrap();
assert_eq!(current.state.lock().task.model.as_deref(), Some("plain"));
assert!(!current.state.lock().task.config.iter().any(config::is_per_model_option));
let catalog = restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp");
assert!(catalog.thought_levels["plain"].is_empty());
assert!(!catalog.thought_levels.contains_key("small"), "obsolete discovery cannot populate model settings");
assert_eq!(agent.calls.lock().iter().filter(|call| *call == "session/new").count(), 2);
assert!(!agent.calls.lock().iter().any(|call| call == "session/prompt"));
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)] {
+6 -22
Переглянути файл
@@ -47,20 +47,13 @@ pub fn plan(root: &Path, model: &BuildModel, module: &Path, cache: &Path) -> Ide
fs::write(
&script,
format!(
r#"import org.gradle.util.GradleVersion
gradle.projectsEvaluated {{
r#"gradle.projectsEvaluated {{
def p = gradle.rootProject.project({})
def update = {{ t ->
t.dependsOn 'processResources'
// Resolved here so the action holds no task or project (configuration cache).
def dir = p.tasks.getByName('processResources').destinationDir
def manifest = new File({})
t.doLast {{ manifest.setText(dir.absolutePath, 'UTF-8') }}
def resources = p.tasks.named('processResources')
p.tasks.register('openideaUpdateResources') {{
dependsOn resources
doLast {{ new File({}).setText(resources.get().destinationDir.absolutePath, 'UTF-8') }}
}}
// `register` is Gradle 4.9+.
if (GradleVersion.current() >= GradleVersion.version('4.9')) p.tasks.register('openideaUpdateResources', update)
else p.tasks.create('openideaUpdateResources', update)
}}
"#,
literal(&p.path),
@@ -179,16 +172,7 @@ mod tests {
assert_eq!(gradle.command, "/tools/gradlew");
assert_eq!(gradle.args.last().unwrap(), ":app:openideaUpdateResources");
let script = fs::read_to_string(cache.join("resources.init.gradle")).unwrap();
assert!(
script.contains("processResources")
&& script.contains(".destinationDir\n")
&& script.contains("setText(dir.absolutePath")
);
// `register` is Gradle 4.9+ (#3864).
assert!(script.contains("else p.tasks.create('openideaUpdateResources', update)"), "{script}");
// The configuration cache can't serialize a task or project the action refers to.
let action = &script[script.find("doLast").unwrap()..script.find("// `register`").unwrap()];
assert!(!action.contains("p.") && !action.contains("tasks"), "{action}");
assert!(script.contains("processResources") && script.contains("destinationDir.absolutePath"));
assert!(!script.contains("build/resources/main")); // The task owns custom output locations.
}
+3 -7
Переглянути файл
@@ -30,8 +30,7 @@ def processedResources = { Project p, s ->
def describe = { Project p ->
def m = [path: identity(p), dir: canon(p.projectDir), buildDir: canon(p.layout.buildDirectory.get().asFile)]
if (p.gradle.parent != null) m.build = identity(p.rootProject)
// Gradle 4.x has it as a convention property, not an extension.
def sets = p.extensions.findByName('sourceSets') ?: p.findProperty('sourceSets')
def sets = p.extensions.findByName('sourceSets')
if (sets != null) {
// Test source sets as IDEA classifies them: `test`, test fixtures, JVM test suites,
// and sets whose folders the `idea` plugin lists as test sources.
@@ -52,12 +51,9 @@ def describe = { Project p ->
}
}
try {
// `java` is Gradle 4.10+ (a convention before), its toolchain 6.7+.
def java = p.extensions.findByName('java')
def lv = null
try { lv = java?.toolchain?.languageVersion?.getOrNull() } catch (ignored) {}
def target = java != null ? java.targetCompatibility : p.findProperty('targetCompatibility')
m.java = lv != null ? lv.asInt() : (target?.majorVersion as Integer)
def lv = java?.toolchain?.languageVersion?.getOrNull()
m.java = lv != null ? lv.asInt() : (java?.targetCompatibility?.majorVersion as Integer)
} catch (ignored) {}
println '@openidea-model\t' + JsonOutput.toJson(m)
}
+1 -83
Переглянути файл
@@ -1,16 +1,13 @@
//! A Gradle project's resolved dependencies for the Dependency Analyzer:
//! `gradle <project>:dependencies --configuration <name>`, parsed from its tree report.
//! The reports it read are kept per build ([`save_gradle_report`]) until a build file
//! changes, for readers that must not run Gradle themselves (plugins).
use crate::gradle;
use crate::process;
use crate::sync::{self, SyncOptions, error_summary};
use crate::sync::{SyncOptions, error_summary};
use ide_core::{CancellationToken, IdeError, IdeResult};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::Path;
use std::sync::Mutex;
/// One line of the report: an occurrence of a dependency where it is requested.
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
@@ -161,54 +158,6 @@ pub fn gradle_dependencies(
Ok(parse_report(&out.text))
}
/// A `dependencies` report of one project of a build for one configuration.
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct GradleReport {
/// Gradle path of the project (`:`, `:app`).
pub project: String,
pub configuration: String,
pub dependencies: Vec<GradleDependency>,
}
#[derive(Default, Serialize, Deserialize)]
struct ReportCache {
/// The build files the reports were read with ([`sync::hash_gradle_files`]).
hash: String,
reports: Vec<GradleReport>,
}
const REPORT_CACHE: &str = "gradle-dependencies.json";
/// Keeps `report` with the build's other reports (`cache_dir` is the build's cache
/// directory), replacing an earlier one of the same project and configuration. Reports
/// read before a build file changed are dropped.
pub fn save_gradle_report(
root: &Path,
cache_dir: &Path,
model: &gradle::GradleModel,
report: &GradleReport,
) -> IdeResult<()> {
// Reports of several configurations may finish together: one read-modify-write at a time.
static SAVING: Mutex<()> = Mutex::new(());
let _saving = SAVING.lock().unwrap_or_else(|e| e.into_inner());
let hash = sync::hash_gradle_files(&gradle::build_files(root, model));
let mut cache = sync::read_cache::<ReportCache>(cache_dir, REPORT_CACHE)
.filter(|c| c.hash == hash)
.unwrap_or_else(|| ReportCache { hash, reports: Vec::new() });
cache.reports.retain(|r| (&r.project, &r.configuration) != (&report.project, &report.configuration));
cache.reports.push(report.clone());
sync::write_cache(cache_dir, REPORT_CACHE, &cache)
}
/// The reports kept for the build, unless a build file changed since they were read.
pub fn gradle_reports(root: &Path, cache_dir: &Path, model: &gradle::GradleModel) -> Vec<GradleReport> {
let Some(cache) = sync::read_cache::<ReportCache>(cache_dir, REPORT_CACHE) else { return Vec::new() };
if cache.hash != sync::hash_gradle_files(&gradle::build_files(root, model)) {
return Vec::new();
}
cache.reports
}
#[cfg(test)]
mod tests {
use super::*;
@@ -285,37 +234,6 @@ runtimeClasspath - Runtime classpath of source set 'main'.
);
}
#[test]
fn reports_are_kept_per_project_and_configuration_until_a_build_file_changes() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path();
let cache = root.join("cache");
std::fs::write(root.join("settings.gradle"), "include 'app'").unwrap();
std::fs::write(root.join("build.gradle"), "").unwrap();
let model = gradle::load(root).unwrap();
assert!(gradle_reports(root, &cache, &model).is_empty());
let report = |project: &str, configuration: &str, version: &str| GradleReport {
project: project.into(),
configuration: configuration.into(),
dependencies: vec![dep("org.a", "b", Some(version))],
};
save_gradle_report(root, &cache, &model, &report(":app", "runtimeClasspath", "1.0")).unwrap();
save_gradle_report(root, &cache, &model, &report(":app", "compileClasspath", "1.0")).unwrap();
// Reading a report again replaces what was read before.
save_gradle_report(root, &cache, &model, &report(":app", "runtimeClasspath", "2.0")).unwrap();
assert_eq!(
gradle_reports(root, &cache, &model),
[report(":app", "compileClasspath", "1.0"), report(":app", "runtimeClasspath", "2.0")]
);
// A comment changes nothing Gradle reads; a dependency does.
std::fs::write(root.join("build.gradle"), "// notes").unwrap();
assert_eq!(gradle_reports(root, &cache, &model).len(), 2);
std::fs::write(root.join("build.gradle"), "dependencies { implementation 'org.a:b:3.0' }").unwrap();
assert!(gradle_reports(root, &cache, &model).is_empty());
save_gradle_report(root, &cache, &model, &report(":", "compileClasspath", "3.0")).unwrap();
assert_eq!(gradle_reports(root, &cache, &model), [report(":", "compileClasspath", "3.0")]);
}
#[cfg(unix)]
#[test]
fn runs_the_report_of_the_project_and_configuration() {
+5 -70
Переглянути файл
@@ -19,7 +19,7 @@ pub mod web;
mod xml;
pub use gradle::{GradleModel, GradleProject, GradleTask};
pub use gradle_deps::{GradleDependency, GradleReport, gradle_dependencies, gradle_reports, save_gradle_report};
pub use gradle_deps::{GradleDependency, gradle_dependencies};
pub use maven::{MavenDependency, MavenModel, MavenPlugin, MavenProfile, MavenProject, Omission};
pub use sbt::{SbtBuild, SbtProject};
pub use sync::{
@@ -127,22 +127,10 @@ pub fn gradle_external_roots(
gradle::external_roots(root, dirs.iter().map(String::as_str))
}
/// Directories outside `root`, outermost only, of Maven POMs linked from there and, in a
/// trusted project, of the modules its reactor lists there (`<module>../service-a</module>`):
/// extra content roots, as IDEA imports such modules with content roots of their own.
/// Linked POMs are read as explicit paths; the reactor's POMs are parsed, but not their
/// parents, and nothing walks directories. `cache_dir` holds the profiles chosen at the last sync.
pub fn maven_external_roots(
root: &Path,
cache_dir: &Path,
settings: &ide_core::settings::MavenSettings,
trusted: bool,
) -> Vec<PathBuf> {
let mut dirs = maven::external_pom_dirs(root, &settings.linked_projects);
if trusted {
let profiles = settings.profiles(&sync::maven_profiles(cache_dir));
dirs.extend(maven::reactor_external_dirs(root, &profiles, &settings.unlinked_projects));
}
/// Directories of Maven POMs linked from outside `root`, outermost only.
/// Reads just those explicit paths (no POM parse and no directory walk).
pub fn maven_external_roots(root: &Path, linked: &[String]) -> Vec<PathBuf> {
let dirs = maven::external_pom_dirs(root, linked);
let owned: Vec<String> = dirs.iter().map(|dir| dir.to_string_lossy().into_owned()).collect();
gradle::external_roots(root, owned.iter().map(String::as_str))
}
@@ -263,59 +251,6 @@ mod tests {
assert!(gradle_external_roots(&root, &temp.path().join("cache"), &settings).is_empty());
}
#[test]
fn reactor_modules_outside_the_root_are_content_roots_of_a_trusted_project() {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let root = base.join("workspace");
let cache = base.join("cache");
let write = |rel: &str, text: &str| {
let path = base.join(rel).join("pom.xml");
std::fs::create_dir_all(path.parent().unwrap()).unwrap();
std::fs::write(path, format!("<project><artifactId>{rel}</artifactId>{text}</project>")).unwrap();
};
let reactor = |modules: &str| {
format!(
"<packaging>pom</packaging><modules>{modules}</modules>\
<profiles><profile><id>extra</id><modules><module>../service-c</module></modules></profile></profiles>"
)
};
let all = "<module>core</module><module>../service-a</module><module>..</module>";
write("workspace", &reactor(all));
write("workspace/core", "<modules><module>../../service-d</module></modules>");
write("service-a", "<modules><module>impl</module><module>../service-e</module></modules>");
for module in ["service-a/impl", "service-c", "service-d", "service-e", "unrelated"] {
write(module, "");
}
// The folder holding the project is not a module beside it, nor are its other modules.
write("", "<modules><module>workspace</module><module>unrelated</module></modules>");
let mut settings = ide_core::settings::MavenSettings::default();
let roots = |settings: &ide_core::settings::MavenSettings, trusted| {
maven_external_roots(&root, &cache, settings, trusted)
};
let (a, c, d, e) =
(base.join("service-a"), base.join("service-c"), base.join("service-d"), base.join("service-e"));
assert_eq!(roots(&settings, true), [a.clone(), d.clone(), e.clone()]);
assert!(roots(&settings, false).is_empty(), "Restricted Mode does not widen the index");
settings.active_profiles = "extra".into();
assert_eq!(roots(&settings, true), [a.clone(), c.clone(), d.clone(), e.clone()]);
save_maven_profiles(&cache, &["!extra".into()]).unwrap();
assert_eq!(roots(&settings, true), [a.clone(), d.clone(), e.clone()]);
settings.unlinked_projects = vec![a.join("pom.xml").to_string_lossy().replace('\\', "/")];
assert_eq!(roots(&settings, true), std::slice::from_ref(&d));
settings.unlinked_projects.clear();
write("workspace", &reactor("<module>core</module>"));
assert_eq!(roots(&settings, true), std::slice::from_ref(&d));
write("workspace/core", "");
assert!(roots(&settings, true).is_empty());
write("workspace", &reactor(all));
assert_eq!(roots(&settings, true), [a, e]);
}
#[test]
fn settings_profiles_and_checkbox_choices_control_modules_before_sync() {
let tmp = tempfile::tempdir().unwrap();
+2 -86
Переглянути файл
@@ -1235,86 +1235,6 @@ pub fn external_pom_dirs(root: &Path, linked: &[String]) -> Vec<PathBuf> {
out
}
type FileStamp = Option<(Option<std::time::SystemTime>, u64)>;
fn file_stamp(path: &Path) -> FileStamp {
std::fs::metadata(path).ok().map(|m| (m.modified().ok(), m.len()))
}
/// The POM files a reactor walk read or looked for, and the module folders it found outside the root.
struct ReactorScan {
stamps: Vec<(PathBuf, FileStamp)>,
dirs: Vec<PathBuf>,
}
/// Folders of the modules that the reactor of `root/pom.xml` lists outside `root`
/// (`<module>../service-a</module>`), with their own modules in turn, including those of
/// the active `profiles`. An `unlinked` POM leaves out its modules too. A folder that
/// holds `root` (`<module>..</module>`) is not a module beside the project and is skipped.
/// Callers keep the outermost directory only. Memoized on the POMs' modification times and
/// sizes: content roots are read on hot paths (every references search, Find in Files).
pub fn reactor_external_dirs(root: &Path, profiles: &[String], unlinked: &[String]) -> Vec<PathBuf> {
type Memo = HashMap<(PathBuf, Vec<String>, Vec<String>), ReactorScan>;
static MEMO: std::sync::LazyLock<Mutex<Memo>> = std::sync::LazyLock::new(Default::default);
let key = (root.to_path_buf(), profiles.to_vec(), unlinked.to_vec());
if let Some(scan) = MEMO.lock().unwrap_or_else(|e| e.into_inner()).get(&key)
&& scan.stamps.iter().all(|(path, stamp)| file_stamp(path) == *stamp)
{
return scan.dirs.clone();
}
let scan = scan_reactor(root, profiles, unlinked);
let dirs = scan.dirs.clone();
MEMO.lock().unwrap_or_else(|e| e.into_inner()).insert(key, scan);
dirs
}
/// Reads only the POMs the reactor lists (no parent resolution and no directory walk).
fn scan_reactor(root: &Path, profiles: &[String], unlinked: &[String]) -> ReactorScan {
let canonical_root = dunce::canonicalize(root).unwrap_or_else(|_| root.to_path_buf());
let chosen = Resolver::new(None, profiles);
let unlinked: HashSet<String> = unlinked.iter().map(|p| normalized_pom(p.trim())).collect();
let first = root.join("pom.xml");
let mut scan = ReactorScan { stamps: vec![(first.clone(), file_stamp(&first))], dirs: Vec::new() };
let mut seen: HashSet<PathBuf> = HashSet::new();
let mut pending = vec![first];
while let Some(path) = pending.pop() {
if seen.len() >= MAX_PROJECTS {
break;
}
let canonical = dunce::canonicalize(&path).unwrap_or_else(|_| path.clone());
if !seen.insert(canonical.clone()) || unlinked.contains(&project_rel(&canonical_root, &canonical)) {
continue;
}
let Some(pom) = xml::read_text(&path).as_deref().and_then(parse_pom) else { continue };
let dir = path.parent().unwrap_or(root).to_path_buf();
let dir_canon = dunce::canonicalize(&dir).unwrap_or_else(|_| dir.clone());
if !dir_canon.starts_with(&canonical_root) {
if canonical_root.starts_with(&dir_canon) {
continue;
}
scan.dirs.push(dir_canon);
}
let active: Vec<&RawProfile> = chosen.active(&pom.profiles).collect();
let props: HashMap<String, String> =
pom.properties.iter().chain(active.iter().flat_map(|p| &p.properties)).cloned().collect();
for module in pom.modules.iter().chain(active.iter().flat_map(|p| &p.modules)) {
let module = interpolate(module, &props);
if module.contains("${") {
continue;
}
let mut mp = crate::gradle::normalize(&dir.join(module));
if mp.is_dir() || mp.extension().is_none_or(|e| e != "xml") {
mp.push("pom.xml");
}
scan.stamps.push((mp.clone(), file_stamp(&mp)));
if mp.is_file() {
pending.push(mp);
}
}
}
scan
}
/// Whether `root` holds a Maven build or the settings link one inside it.
pub fn has_projects(root: &Path, settings: &ide_core::settings::MavenSettings) -> bool {
is_maven_project(root) || !linked_poms(root, &settings.linked_projects).is_empty()
@@ -2559,12 +2479,8 @@ mod tests {
assert_eq!(normalized[0], dunce::canonicalize(b.join("pom.xml")).unwrap().to_string_lossy().replace('\\', "/"));
assert_eq!(normalized[1], "pom.xml");
assert_eq!(normalized[2], "stub/pom.xml");
let external_roots = |linked: &[String]| {
let settings = ide_core::settings::MavenSettings { linked_projects: linked.to_vec(), ..Default::default() };
crate::maven_external_roots(&a, &base.join("cache"), &settings, true)
};
assert_eq!(external_roots(&normalized), vec![b.clone()]);
assert_eq!(external_roots(&stored), vec![b.clone()]);
assert_eq!(crate::maven_external_roots(&a, &normalized), vec![b.clone()]);
assert_eq!(crate::maven_external_roots(&a, &stored), vec![b.clone()]);
let removed = load_with_linked(&a, None, &[], &[]);
assert!(removed.projects.iter().all(|p| p.artifact_id != "b"));
+3 -3
Переглянути файл
@@ -136,11 +136,11 @@ pub fn save_maven_profiles(cache_dir: &Path, profiles: &[String]) -> IdeResult<b
Ok(true)
}
pub(crate) fn read_cache<T: DeserializeOwned>(dir: &Path, name: &str) -> Option<T> {
fn read_cache<T: DeserializeOwned>(dir: &Path, name: &str) -> Option<T> {
serde_json::from_slice(&std::fs::read(dir.join(name)).ok()?).ok()
}
pub(crate) fn write_cache<T: Serialize>(dir: &Path, name: &str, value: &T) -> IdeResult<()> {
fn write_cache<T: Serialize>(dir: &Path, name: &str, value: &T) -> IdeResult<()> {
std::fs::create_dir_all(dir)?;
let json = serde_json::to_vec(value).map_err(|e| IdeError::internal(e.to_string()))?;
let tmp = dir.join(format!("{name}.tmp"));
@@ -156,7 +156,7 @@ fn hash_files(files: &[PathBuf]) -> String {
/// Like IDEA's auto-import CRC: editing a comment or reformatting a build script
/// does not make the last sync stale.
pub(crate) fn hash_gradle_files(files: &[PathBuf]) -> String {
fn hash_gradle_files(files: &[PathBuf]) -> String {
hash_contents(files, |f| {
let text = std::fs::read_to_string(f).unwrap_or_default();
let script = f.extension().is_some_and(|e| e == "gradle" || e == "kts");
+7 -26
Переглянути файл
@@ -172,25 +172,13 @@ pub fn build(root: &Path, model: &BuildModel, id: &str, cache: &Path) -> IdeResu
fs::write(
&script,
format!(
r#"import org.gradle.util.GradleVersion
gradle.projectsEvaluated {{
r#"gradle.projectsEvaluated {{
def p = gradle.rootProject.project({})
def artifact = {{ t ->
t.dependsOn 'war'
// Resolved here so the action holds no task or project (configuration cache).
def war = p.tasks.getByName('war')
// `archiveFile` is Gradle 5.1+, `archivePath` is gone in 8.0.
def archive = war.hasProperty('archiveFile') ? war.archiveFile : war.archivePath
def manifest = new File({})
t.doLast {{
def file = archive instanceof File ? archive : archive.get().asFile
manifest.setText(file.absolutePath, 'UTF-8')
}}
def warTask = p.tasks.named('war')
p.tasks.register('openideaTomcatArtifact') {{
dependsOn warTask
doLast {{ new File({}).setText(warTask.get().archiveFile.get().asFile.absolutePath, 'UTF-8') }}
}}
// `register` is Gradle 4.9+.
if (GradleVersion.current() >= GradleVersion.version('4.9')) p.tasks.register('openideaTomcatArtifact', artifact)
else p.tasks.create('openideaTomcatArtifact', artifact)
}}
"#,
groovy_literal(path),
@@ -282,7 +270,7 @@ mod tests {
assert_eq!(a.len(), 1);
let plan = build(tmp.path(), &model, &a[0].id, &tmp.path().join("base")).unwrap();
assert!(plan.args.contains(&":openideaTomcatArtifact".into()));
assert!(fs::read_to_string(tmp.path().join("base/war.init.gradle")).unwrap().contains("? war.archiveFile :"));
assert!(fs::read_to_string(tmp.path().join("base/war.init.gradle")).unwrap().contains("archiveFile.get()"));
assert!(!crate::gradle::has_war_plugin("// plugins { war }"));
}
@@ -309,14 +297,7 @@ mod tests {
assert!(plan.args.contains(&format!("{}:openideaTomcatArtifact", module.trim_end_matches(':'))));
let script = fs::read_to_string(cache.join("war.init.gradle")).unwrap();
assert!(script.contains(&format!("rootProject.project('{}')", module)));
assert!(script.contains("manifest.setText(file.absolutePath, 'UTF-8')"));
// `archiveFile` is Gradle 5.1+, `register` 4.9+ (#3864).
assert!(
script.contains(": war.archivePath") && script.contains("else p.tasks.create('openideaTomcatArtifact'")
);
// The configuration cache can't serialize a task or project the action refers to.
let action = &script[script.find("doLast").unwrap()..script.find("// `register`").unwrap()];
assert!(!action.contains("p.") && !action.contains("war."), "{action}");
assert!(script.contains("archiveFile.get().asFile.absolutePath, 'UTF-8'"));
}
}
}
-3
Переглянути файл
@@ -343,8 +343,6 @@ pub struct InlayHintsSettings {
/// Hints of other kinds (chaining, closing labels…).
pub other: bool,
pub disabled_languages: Vec<String>,
/// Code vision as a whole (usages, author and language-server lenses); the switches below apply while it is on.
pub code_vision: bool,
/// Code vision: usages above declarations.
pub code_vision_usages: bool,
/// Code vision: last author of a declaration (VCS blame) beside its usages.
@@ -375,7 +373,6 @@ impl Default for InlayHintsSettings {
parameters: true,
other: true,
disabled_languages: Vec::new(),
code_vision: true,
code_vision_usages: true,
code_vision_author: true,
code_vision_no_usages: true,
+5 -8
Переглянути файл
@@ -167,11 +167,10 @@ const GRADLE: &[&str] = &["gradle", "gradlew"];
/// Gradle's own JVM and the compiler's source encoding are untouched.
pub const GRADLE_FILE_ENCODING_SCRIPT: &str = "\
// Written by OpenIDEA: a UTF-8 default charset for applications run by Gradle, as the Run console decodes UTF-8.
import org.gradle.util.GradleVersion
// `configureEach` (lazy) is Gradle 4.9+; older ones configure each task as it is added.
def each = { tasks, Closure action -> GradleVersion.current() >= GradleVersion.version('4.9') ? tasks.configureEach(action) : tasks.all(action) }
allprojects {
each(tasks.withType(JavaExec)) { t -> t.defaultCharacterEncoding = 'UTF-8' }
tasks.withType(JavaExec).configureEach {
defaultCharacterEncoding = 'UTF-8'
}
}
";
@@ -622,12 +621,10 @@ mod tests {
#[test]
fn gradle_script_respects_the_builds_own_file_encoding() {
let s = GRADLE_FILE_ENCODING_SCRIPT;
assert!(s.contains("each(tasks.withType(JavaExec))"), "{s}");
assert!(s.contains("t.defaultCharacterEncoding = 'UTF-8'"), "{s}");
assert!(s.contains("tasks.withType(JavaExec).configureEach"), "{s}");
assert!(s.contains("defaultCharacterEncoding = 'UTF-8'"), "{s}");
assert!(!s.contains("doFirst"), "the build must be able to override the default: {s}");
assert!(!s.contains("withType(Test)") && !s.contains("JavaCompile"), "{s}");
// Gradle before 4.9 has no `configureEach` (#3864).
assert!(s.contains("? tasks.configureEach(action) : tasks.all(action)"), "{s}");
}
#[test]
-96
Переглянути файл
@@ -1,6 +1,3 @@
use serde::{Deserialize, Serialize};
use specta::Type;
/// The Windows OS build used by ConPTY; unavailable on other platforms or on query failure.
#[cfg(windows)]
pub fn windows_build_number() -> Option<u32> {
@@ -19,61 +16,6 @@ pub fn windows_build_number() -> Option<u32> {
None
}
/// A caption button of a frameless window's title bar.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum WindowButton {
Minimize,
Maximize,
Close,
}
/// Which caption buttons the title bar shows on each side, in order from left to right.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct WindowButtonLayout {
pub left: Vec<WindowButton>,
pub right: Vec<WindowButton>,
}
impl Default for WindowButtonLayout {
/// Minimise, maximise, close on the right (Windows, and Linux when the desktop says nothing).
fn default() -> Self {
Self { left: Vec::new(), right: vec![WindowButton::Minimize, WindowButton::Maximize, WindowButton::Close] }
}
}
impl WindowButtonLayout {
/// Reads GTK's `gtk-decoration-layout` (also GNOME's `button-layout`): button names separated
/// by commas, the left side before the colon, e.g. `close,maximize,minimize:icon`. Names other
/// than the three caption buttons (`icon`, `menu`, `appmenu`, `spacer`) are skipped, as are
/// repeats. A value without any caption button is unusable for a frameless window: `None`.
pub fn from_gtk_decoration_layout(layout: &str) -> Option<Self> {
let mut seen = Vec::new();
let mut side = |part: Option<&str>| {
let mut buttons = Vec::new();
for name in part.unwrap_or_default().split(',') {
let button = match name.trim() {
"minimize" => WindowButton::Minimize,
"maximize" => WindowButton::Maximize,
"close" => WindowButton::Close,
_ => continue,
};
if !seen.contains(&button) {
seen.push(button);
buttons.push(button);
}
}
buttons
};
// GTK splits at the first colon only; without one, every button is on the left.
let mut parts = layout.splitn(2, ':');
let left = side(parts.next());
let right = side(parts.next());
(!left.is_empty() || !right.is_empty()).then_some(Self { left, right })
}
}
#[cfg(test)]
mod tests {
#[test]
@@ -84,42 +26,4 @@ mod tests {
#[cfg(not(windows))]
assert_eq!(build, None);
}
use super::{WindowButton::*, WindowButtonLayout};
fn layout(left: &[super::WindowButton], right: &[super::WindowButton]) -> Option<WindowButtonLayout> {
Some(WindowButtonLayout { left: left.to_vec(), right: right.to_vec() })
}
#[test]
fn reads_gtk_decoration_layouts() {
let cases = [
// KDE Plasma with `ButtonsOnLeft=XAIS` (#3794).
("close,maximize,minimize:icon", layout(&[Close, Maximize, Minimize], &[])),
("close,minimize,maximize:", layout(&[Close, Minimize, Maximize], &[])),
(":minimize,maximize,close", layout(&[], &[Minimize, Maximize, Close])),
// GNOME's default.
("appmenu:close", layout(&[], &[Close])),
("menu:minimize,close", layout(&[], &[Minimize, Close])),
("icon,close:minimize,maximize", layout(&[Close], &[Minimize, Maximize])),
(" close , spacer : minimize ", layout(&[Close], &[Minimize])),
// No colon: GTK puts everything on the left.
("close,minimize", layout(&[Close, Minimize], &[])),
// Only the first colon separates the sides; a button appears once.
("close:minimize:maximize", layout(&[Close], &[])),
("close,close:close,minimize", layout(&[Close], &[Minimize])),
("", None),
(":", None),
("appmenu:", None),
("garbage", None),
];
for (value, expected) in cases {
assert_eq!(WindowButtonLayout::from_gtk_decoration_layout(value), expected, "{value:?}");
}
}
#[test]
fn default_layout_is_on_the_right() {
assert_eq!(WindowButtonLayout::default(), layout(&[], &[Minimize, Maximize, Close]).unwrap());
}
}
+1 -94
Переглянути файл
@@ -653,10 +653,6 @@ pub struct NotificationSettings {
/// Mirror balloon notifications to the OS when no OpenIDEA window is focused.
#[serde(default = "default_true")]
pub system_notifications: bool,
/// Terminal command completions (#3712): `off` | `longRunning` | `all`.
pub terminal_completion: String,
/// `longRunning`: the run time a finished command must reach, in seconds.
pub terminal_threshold_seconds: u32,
/// Group id → display; groups not listed use their default.
pub groups: BTreeMap<String, NotificationGroupSettings>,
}
@@ -665,24 +661,9 @@ fn default_true() -> bool {
true
}
fn default_terminal_completion() -> String {
"longRunning".to_owned()
}
fn default_terminal_threshold_seconds() -> u32 {
10
}
impl Default for NotificationSettings {
fn default() -> Self {
Self {
balloons: true,
sound: false,
system_notifications: true,
terminal_completion: default_terminal_completion(),
terminal_threshold_seconds: default_terminal_threshold_seconds(),
groups: BTreeMap::new(),
}
Self { balloons: true, sound: false, system_notifications: true, groups: BTreeMap::new() }
}
}
@@ -760,9 +741,6 @@ pub struct AppearanceSettings {
pub main_menu_style: String,
/// A lone Alt press focuses or opens the main menu (IDEA `ide.windows.main.menu.focus.on.alt`).
pub main_menu_alt: bool,
/// Settings open in a native window of their own (IDEA parity); off opens them
/// as a dialog inside the project window, which needs no new webview.
pub settings_in_separate_window: bool,
/// `subpixel` | `greyscale` | `none`
pub ide_antialiasing: String,
pub editor_antialiasing: String,
@@ -862,7 +840,6 @@ impl Default for AppearanceSettings {
menu_icons: true,
main_menu_style: "hamburger".into(),
main_menu_alt: true,
settings_in_separate_window: true,
ide_antialiasing: "greyscale".into(),
editor_antialiasing: "greyscale".into(),
show_tool_window_bars: true,
@@ -915,13 +892,7 @@ pub struct EditorSettings {
pub docstring_format: String,
/// Color Scheme › Language Defaults › Rainbow brackets: `()`, `[]`, `{}` coloured by depth.
pub rainbow_brackets: bool,
/// The bracket kinds rainbow brackets colour.
pub rainbow_bracket_kinds: RainbowBracketKinds,
/// Colours the rainbow bracket depth cycles through (2–5).
pub rainbow_bracket_colors: u32,
pub ligatures: bool,
/// Editor › Font and Tools › Terminal › Font: the font pickers list only monospaced fonts.
pub only_monospaced_fonts: bool,
/// Fallback font for glyphs the main font lacks; empty = none.
pub fallback_font: String,
/// Typography Settings › Main font weight (CSS 100–900), as IDEA.
@@ -965,10 +936,7 @@ impl Default for EditorSettings {
semantic_highlighting: false,
docstring_format: "rest".into(),
rainbow_brackets: false,
rainbow_bracket_kinds: RainbowBracketKinds::default(),
rainbow_bracket_colors: 3,
ligatures: false,
only_monospaced_fonts: true,
fallback_font: String::new(),
font_weight: 400,
bold_font_weight: 700,
@@ -991,23 +959,6 @@ impl Default for EditorSettings {
}
}
/// Color Scheme › Language Defaults › Rainbow brackets: which delimiters are coloured.
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct RainbowBracketKinds {
pub round: bool,
pub square: bool,
pub curly: bool,
/// Type argument / parameter delimiters and markup tags, where the syntax tree marks them.
pub angle: bool,
}
impl Default for RainbowBracketKinds {
fn default() -> Self {
Self { round: true, square: true, curly: true, angle: false }
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Type)]
#[serde(default, rename_all = "camelCase")]
pub struct FileSettings {
@@ -1800,41 +1751,6 @@ mod tests {
}
}
#[test]
fn rainbow_bracket_options_default_and_round_trip() {
let old: Settings = serde_json::from_str(r#"{"editor":{"rainbowBrackets":true}}"#).unwrap();
assert!(old.editor.rainbow_brackets);
assert_eq!(old.editor.rainbow_bracket_kinds, RainbowBracketKinds::default());
assert_eq!(old.editor.rainbow_bracket_colors, 3);
let defaults = Settings::default().editor;
assert!(!defaults.rainbow_brackets);
let kinds = defaults.rainbow_bracket_kinds;
assert!(kinds.round && kinds.square && kinds.curly && !kinds.angle);
let mut settings = Settings::default();
settings.editor.rainbow_bracket_kinds =
RainbowBracketKinds { round: false, square: true, curly: true, angle: true };
settings.editor.rainbow_bracket_colors = 5;
let json = serde_json::to_value(&settings).unwrap();
assert_eq!(json["editor"]["rainbowBracketKinds"]["angle"], true);
assert_eq!(json["editor"]["rainbowBracketColors"], 5);
let restored: Settings = serde_json::from_value(json).unwrap();
assert_eq!(restored.editor.rainbow_bracket_kinds, settings.editor.rainbow_bracket_kinds);
assert_eq!(restored.editor.rainbow_bracket_colors, 5);
}
#[test]
fn only_monospaced_fonts_defaults_on_and_round_trips() {
let old: Settings = serde_json::from_str(r#"{"editor":{"ligatures":true}}"#).unwrap();
assert!(old.editor.only_monospaced_fonts);
let mut settings = Settings::default();
settings.editor.only_monospaced_fonts = false;
let json = serde_json::to_value(&settings).unwrap();
assert_eq!(json["editor"]["onlyMonospacedFonts"], false);
let restored: Settings = serde_json::from_value(json).unwrap();
assert!(!restored.editor.only_monospaced_fonts);
}
#[test]
fn docstring_format_defaults_and_round_trips() {
let old: Settings = serde_json::from_str(r#"{"editor":{"semanticHighlighting":true}}"#).unwrap();
@@ -1933,15 +1849,6 @@ mod tests {
assert_eq!(serde_json::to_value(off).unwrap()["appearance"]["mainMenuAlt"], false);
}
#[test]
fn settings_open_in_a_separate_window_unless_turned_off() {
let old: Settings = serde_json::from_str(r#"{"appearance":{"compactMode":true}}"#).unwrap();
assert!(old.appearance.settings_in_separate_window);
let off: Settings = serde_json::from_str(r#"{"appearance":{"settingsInSeparateWindow":false}}"#).unwrap();
assert!(!off.appearance.settings_in_separate_window);
assert_eq!(serde_json::to_value(off).unwrap()["appearance"]["settingsInSeparateWindow"], false);
}
#[test]
fn editor_font_weights_default_to_regular_and_bold() {
let json = serde_json::to_value(Settings::default()).unwrap();
-7
Переглянути файл
@@ -43,9 +43,6 @@ impl Default for VcsSettings {
pub struct GitSettings {
/// Show blame after the current editor line.
pub inline_blame: bool,
/// A click (or Enter / Space) on the inline blame label opens its commit; off, the
/// label is plain text and a click on it places the caret as past the line end.
pub inline_blame_clickable: bool,
pub show_branch_in_project_view: bool,
/// Path to the git executable; empty = auto-detect.
pub executable: String,
@@ -57,8 +54,6 @@ pub struct GitSettings {
pub warn_detached_head: bool,
/// Background check for incoming commits: `auto` | `always` | `never`.
pub incoming_check: String,
/// Minutes between background checks for incoming commits.
pub incoming_check_interval: u32,
/// Branch name globs, `;`/`,`-separated; force push to them is prohibited.
pub protected_branches: String,
/// Initial state of Commit Options › Sign-off Commit.
@@ -83,7 +78,6 @@ impl Default for GitSettings {
fn default() -> Self {
Self {
inline_blame: false,
inline_blame_clickable: true,
show_branch_in_project_view: false,
executable: String::new(),
update_method: "merge".into(),
@@ -91,7 +85,6 @@ impl Default for GitSettings {
warn_crlf: true,
warn_detached_head: true,
incoming_check: "auto".into(),
incoming_check_interval: 15,
protected_branches: "master; main".into(),
sign_off: false,
warn_large_files: true,
+6 -14
Переглянути файл
@@ -6,16 +6,11 @@ use ide_run::wrap::{self, program_name};
use std::path::Path;
const GRADLE_INIT: &str = r#"// Written by OpenIDEA for Run with Coverage.
import org.gradle.util.GradleVersion
// `configureEach` (lazy) is Gradle 4.9+; older ones configure each task as it is added.
def each = { tasks, Closure action -> GradleVersion.current() >= GradleVersion.version('4.9') ? tasks.configureEach(action) : tasks.all(action) }
allprojects { p ->
p.plugins.withId('java') {
p.apply plugin: 'jacoco'
each(p.tasks.withType(Test)) { t -> t.finalizedBy('jacocoTestReport') }
def xml = p.tasks.getByName('jacocoTestReport').reports.xml
// `Report.required` is Gradle 6.1+, `enabled` is gone in 8.0.
if (xml.hasProperty('required')) xml.required.set(true) else xml.enabled = true
allprojects {
plugins.withId('java') {
apply plugin: 'jacoco'
tasks.withType(Test).configureEach { t -> t.finalizedBy(tasks.named('jacocoTestReport')) }
tasks.named('jacocoTestReport') { r -> r.reports { xml.required.set(true) } }
}
}
"#;
@@ -396,10 +391,7 @@ mod tests {
let p = prepare(dir.path(), &cfg("gradle", "./gradlew", &[":app:test", "--tests", "*Calc"]), dir.path());
let (l, report) = launch(&p);
assert_eq!(l.args[0], "--init-script");
let script = std::fs::read_to_string(&l.args[1]).unwrap();
assert!(script.contains("p.apply plugin: 'jacoco'"), "{script}");
// `Report.required` is Gradle 6.1+, `configureEach` 4.9+ (#3864).
assert!(script.contains("else xml.enabled = true") && script.contains(": tasks.all(action)"), "{script}");
assert!(std::fs::read_to_string(&l.args[1]).unwrap().contains("jacoco"));
assert!(matches!(report, CoverageReportSpec::Jacoco { .. }));
}
-5
Переглянути файл
@@ -216,11 +216,6 @@ fn settle<T>(result: Result<T, InspectError>) -> IdeResult<Result<T, JvmInspectU
InspectError::TimedOut => U::TimedOut,
InspectError::Closed => U::BackendClosed,
InspectError::Failed(message) => return Err(IdeError::internal(format!("JVM inspector: {message}"))),
// Only the stream trace commands answer these, never the memory view's.
other @ (InspectError::NoSession
| InspectError::NotAtChainStart(_)
| InspectError::Busy
| InspectError::NoTrace) => return Err(IdeError::internal(format!("JVM inspector: {other}"))),
}))
}
+1 -1
Переглянути файл
@@ -23,7 +23,7 @@ use std::time::Duration;
pub use heap::*;
pub use inspect::{JvmFieldsResult, JvmInspectUnavailable, JvmInstancesResult, JvmObjectRef, JvmReferrersResult};
pub(crate) use inspect::{fields, instances, referrers, set_inspector, vm_target, watch_link};
pub(crate) use inspect::{fields, instances, referrers, set_inspector, watch_link};
#[cfg(all(test, unix))]
pub(crate) use scan::watch_for_attached_jvm;
pub(crate) use scan::{JvmFinder, attach_target, find_attached_jvm, find_local_jvm, local_jdwp_port};
-46
Переглянути файл
@@ -19,7 +19,6 @@ mod jvm_memory;
pub mod kotlin;
pub mod kotlin_lsp;
mod session;
mod stream_trace;
pub mod unity;
use adapter::{AdapterLauncher, AdapterSpec, ProcessLauncher};
@@ -40,7 +39,6 @@ use std::path::{Path, PathBuf};
use std::sync::atomic::Ordering;
use std::sync::{Arc, Weak};
use std::time::Duration;
pub use stream_trace::{TracePhase, TraceProgress, TraceRun, TraceUnavailable};
#[derive(Clone, Debug, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
@@ -148,9 +146,6 @@ pub struct DebugCapabilities {
pub js_page: bool,
/// The adapter evaluates expressions while the program runs, without a stack frame.
pub live_evaluate: bool,
/// A stream chain can be traced while the program runs it ([`DebugManager::stream_trace`]).
/// Can change during the session, like `jvm_instances`.
pub stream_trace: bool,
}
/// Result of [`DebugManager::redefine_classes`].
@@ -607,7 +602,6 @@ pub(crate) fn capabilities_from(caps: &Value) -> DebugCapabilities {
jvm_heap: false,
js_page: false,
live_evaluate: false,
stream_trace: false,
}
}
@@ -619,7 +613,6 @@ pub(crate) fn session_capabilities(session: &Session) -> DebugCapabilities {
caps.jvm_heap = JVM_MEMORY_ADAPTERS.contains(&session.adapter.as_str());
caps.js_page = js_debug::is_page(session);
caps.live_evaluate = session.adapter == js_debug::ADAPTER;
caps.stream_trace = stream_trace::available(session);
caps
}
@@ -1624,7 +1617,6 @@ impl DebugManager {
// DAP: a response without the flag continued every thread.
let all = body.get("allThreadsContinued").and_then(Value::as_bool).unwrap_or(true);
session.suspended.resumed(ticket, thread_id, all);
stream_trace::release_done(&session);
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: all });
Ok(())
}
@@ -1673,7 +1665,6 @@ impl DebugManager {
step_settled(&session, sent)?;
// A step runs its thread; other threads stopped by their own events stay stopped.
session.suspended.resumed(ticket, thread_id, false);
stream_trace::release_done(&session);
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
Ok(())
}
@@ -1785,7 +1776,6 @@ impl DebugManager {
.await;
step_settled(&session, sent)?;
session.suspended.resumed(ticket, thread_id, false);
stream_trace::release_done(&session);
session.emit(ide_core::event::DebugEvent::Continued { thread_id, all_threads_continued: true });
Ok(())
}
@@ -1883,42 +1873,6 @@ impl DebugManager {
jvm_memory::referrers(&*self.session(s)?, object, limit).await
}
/// Gives the session the backend for [`Self::stream_trace`] (used by java-debug sessions
/// only); the UI is told to reload the session's capabilities.
pub fn set_stream_tracer(
&self,
s: DebugSessionId,
tracer: Arc<dyn ide_jvm_inspect::StreamTracer>,
) -> IdeResult<()> {
let session = self.session(s)?;
if session.ended.is_cancelled() {
return Err(no_session(s));
}
stream_trace::set_tracer(&session, tracer);
Ok(())
}
/// Traces the stream chain `plan` (the JSON of `ide_streams::RealRunPlan`) while the program
/// runs it, from `thread_id` stopped where the chain starts. Leaves the thread stopped right
/// after the chain's terminal operation. `cancel` stops keeping records; the program runs on.
pub async fn stream_trace(
&self,
s: DebugSessionId,
thread_id: i64,
plan: Value,
cancel: ide_core::CancellationToken,
progress: impl Fn(TraceProgress) + Send + Sync,
) -> IdeResult<TraceRun> {
let session = self.session(s)?;
Ok(stream_trace::run(self, &session, thread_id, &plan, &cancel, &progress).await)
}
/// Ends the running terminal operation by interrupting its thread, then by throwing into it.
/// `None` when no trace runs.
pub async fn stream_trace_abort(&self, s: DebugSessionId) -> IdeResult<Option<ide_jvm_inspect::AbortState>> {
stream_trace::abort(&*self.session(s)?).await
}
/// HotSwap: reloads the classes compiled since the session started (or since the
/// last reload) into the debuggee (java-debug `redefineClasses`).
pub async fn redefine_classes(&self, s: DebugSessionId) -> IdeResult<HotSwapResult> {
-18
Переглянути файл
@@ -114,10 +114,6 @@ pub(crate) struct Session {
pub jvm_located: watch::Sender<bool>,
pub kotlin_mirror: Mutex<Option<crate::kotlin::SourceMirror>>,
pub jvm_memory: tokio::sync::Mutex<crate::JvmMemoryState>,
pub stream_tracer: parking_lot::Mutex<Option<Arc<dyn ide_jvm_inspect::StreamTracer>>>,
pub(crate) stream_trace: parking_lot::Mutex<Option<crate::stream_trace::ActiveTrace>>,
/// The last trace that finished, until the stop its records were read in ends.
pub(crate) stream_trace_done: parking_lot::Mutex<Option<crate::stream_trace::DoneTrace>>,
/// 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>,
@@ -199,13 +195,6 @@ impl Suspension {
self.0.lock().ticket
}
/// The ticket of a stop of `thread` (its own or every thread's) taken after ticket `after`.
pub fn stopped_since(&self, thread: i64, after: u64) -> Option<u64> {
let stops = self.0.lock();
let own = stops.threads.iter().find(|&&(id, _)| id == thread).map(|&(_, ticket)| ticket);
own.max(stops.all).filter(|&ticket| ticket > after)
}
/// After a successful resume-like request for `thread`; `all`: every thread ran.
pub fn resumed(&self, ticket: u64, thread: i64, all: bool) {
self.0.lock().release(Some(thread), all, ticket);
@@ -281,9 +270,6 @@ impl Session {
jvm_located: watch::channel(false).0,
kotlin_mirror: Mutex::new(None),
jvm_memory: tokio::sync::Mutex::default(),
stream_tracer: parking_lot::Mutex::new(None),
stream_trace: parking_lot::Mutex::new(None),
stream_trace_done: parking_lot::Mutex::new(None),
quirks: kotlin_lsp::Quirks::default(),
unity_startup_activity: Mutex::new(Instant::now()),
}
@@ -755,9 +741,6 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
}
"stopped" => {
let all = body.get("allThreadsStopped").and_then(Value::as_bool).unwrap_or(false);
if crate::stream_trace::resume_traced_stop(s, int("threadId"), all) {
return;
}
s.suspended.stopped(int("threadId"), all);
let mut reason = str_("reason").unwrap_or_else(|| "pause".into());
if let Some(quirks) = s.kotlin_lsp_quirks() {
@@ -777,7 +760,6 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
// DAP: an event without the flag continues its thread alone. The UI keeps treating
// it as all threads; the suspension, which holds only threads that stopped, need not.
s.suspended.continued(int("threadId"), all.unwrap_or(false));
crate::stream_trace::release_done(s);
s.emit(DebugEvent::Continued {
thread_id: int("threadId").unwrap_or(0),
all_threads_continued: all.unwrap_or(true),
-433
Переглянути файл
@@ -1,433 +0,0 @@
//! A stream chain traced while the program itself runs it. The JDT LS bundle arms the trace with
//! the thread stopped where the chain starts; the program runs on `continue`, and the bundle holds
//! the thread inside the terminal operation once it has run, until a `stepOut` brings java-debug
//! to a stop of its own in which the records are read.
use crate::jvm_memory::vm_target;
use crate::session::Session;
use crate::{DebugManager, StepKind};
use ide_core::event::DebugEvent;
use ide_core::{CancellationToken, IdeError, IdeResult};
use ide_jvm_inspect::{
AbortState, InspectError, InspectFuture, StreamTracer, TraceCollected, TraceId, TraceState, VmTarget,
};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use specta::Type;
use std::future::Future;
use std::sync::Arc;
use std::time::Duration;
/// Records the bundle keeps; later ones are only counted.
const BUDGET: u32 = 50_000;
const WAIT_MS: u32 = 500;
const STOP_POLL: Duration = Duration::from_millis(20);
const STOP_WAIT: Duration = Duration::from_secs(30);
const RESUME_TIMEOUT: Duration = Duration::from_secs(30);
/// The bundle reaches the JVM through java-debug's own session.
const ADAPTER: &str = "java-debug";
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct TraceProgress {
pub phase: TracePhase,
pub records: u64,
pub dropped: u64,
/// Since the program started running the chain, as the bundle measures it.
pub elapsed_ms: u64,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum TracePhase {
Arming,
Running,
/// The terminal operation runs on, keeping no more records.
RecordingStopped,
Aborting,
/// The terminal operation finished: stepping out of it and reading the records.
Collecting,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum TraceRun {
/// `generation`: the stop the records were read in, the only one their objects are valid in.
Done {
collected: TraceCollected,
generation: u64,
/// Stops of the traced thread while the program ran the chain, resumed unseen.
resumed_stops: u32,
},
Unavailable {
reason: TraceUnavailable,
},
Failed {
detail: String,
},
/// Stop Recording or Abort Operation came before the terminal operation ran.
Cancelled {
detail: String,
},
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
pub enum TraceUnavailable {
/// Not a java-debug session, or no JDT LS bundle behind it.
NoBackend,
NotSuspended,
NotAtChainStart {
detail: String,
},
/// A trace already runs in this session or its JVM.
Busy,
/// java-debug has no debug session for the JVM.
NoSession,
Unsupported {
detail: String,
},
}
/// A trace that finished. Its records keep their objects from being collected until the stop they
/// were read in ends; then the UI no longer shows them and [`release_done`] lets them go.
pub(crate) struct DoneTrace {
tracer: Arc<dyn StreamTracer>,
target: VmTarget,
id: TraceId,
}
/// The stop a finished trace was read in ended (a resume, a step, a `continued` event).
pub(crate) fn release_done(s: &Session) {
let Some(done) = s.stream_trace_done.lock().take() else { return };
let ended = s.ended.clone();
let session = s.id.0;
tokio::spawn(async move {
tokio::select! {
biased;
() = ended.cancelled() => {}
result = done.tracer.release(&done.target, done.id) => {
if let Err(e) = result {
tracing::debug!(session, trace = done.id, "releasing a finished stream trace: {e}");
}
}
}
});
}
/// The session's running trace; `id` is `None` until `arm` answers.
pub(crate) struct ActiveTrace {
tracer: Arc<dyn StreamTracer>,
target: VmTarget,
id: Option<TraceId>,
aborting: bool,
thread_id: i64,
/// From the `continue` that runs the chain until the bundle holds the thread after it.
running: bool,
resumed_stops: u32,
}
/// A stop of the traced thread while the program runs the chain is resumed instead of shown, as
/// IntelliJ does (spec G5): the UI keeps Resume locked meanwhile, and a breakpoint java-debug set
/// since the bundle last switched them off, hit inside the terminal's invoke, would hold that
/// invoke forever. java-debug stops a breakpoint's thread alone; a stop of every thread is shown.
/// `true` when the stop was taken.
pub(crate) fn resume_traced_stop(s: &Arc<Session>, thread_id: Option<i64>, all: bool) -> bool {
let Some(thread_id) = thread_id.filter(|_| !all) else { return false };
{
let mut slot = s.stream_trace.lock();
let Some(active) = slot.as_mut().filter(|a| a.running && a.thread_id == thread_id) else { return false };
active.resumed_stops += 1;
}
let s = s.clone();
tokio::spawn(async move {
let sent =
s.conn.request_timeout("continue", serde_json::json!({ "threadId": thread_id }), RESUME_TIMEOUT).await;
if let Err(e) = sent {
tracing::warn!(session = s.id.0, thread_id, "resuming a stop inside a stream trace: {e}");
}
});
true
}
fn set_running(s: &Session, running: bool) {
if let Some(active) = s.stream_trace.lock().as_mut() {
active.running = running;
}
}
/// Frees the session for the next trace however this one ends, a dropped future included.
struct Claim<'s>(&'s Session);
impl Drop for Claim<'_> {
fn drop(&mut self) {
self.0.stream_trace.lock().take();
}
}
pub(crate) fn set_tracer(s: &Session, tracer: Arc<dyn StreamTracer>) {
*s.stream_tracer.lock() = Some(tracer);
s.emit(DebugEvent::Capabilities);
}
fn tracer(s: &Session) -> Option<Arc<dyn StreamTracer>> {
s.stream_tracer.lock().clone().filter(|_| s.adapter == ADAPTER)
}
pub(crate) fn available(s: &Session) -> bool {
tracer(s).is_some()
}
pub(crate) async fn run(
mgr: &DebugManager,
s: &Session,
thread_id: i64,
plan: &Value,
cancel: &CancellationToken,
progress: &(impl Fn(TraceProgress) + Send + Sync),
) -> TraceRun {
let unavailable = |reason| TraceRun::Unavailable { reason };
let Some(tracer) = tracer(s) else { return unavailable(TraceUnavailable::NoBackend) };
let target = vm_target(s);
let _claim = {
let mut slot = s.stream_trace.lock();
if slot.is_some() {
return unavailable(TraceUnavailable::Busy);
}
*slot = Some(ActiveTrace {
tracer: tracer.clone(),
target: target.clone(),
id: None,
aborting: false,
thread_id,
running: false,
resumed_stops: 0,
});
Claim(s)
};
if !s.suspended.get() {
return unavailable(TraceUnavailable::NotSuspended);
}
// The bundle releases the previous trace itself when this one arms.
s.stream_trace_done.lock().take();
static TOKENS: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(1);
let token =
format!("{}-{}-{}", std::process::id(), s.id.0, TOKENS.fetch_add(1, std::sync::atomic::Ordering::Relaxed));
let mut trace = Trace {
mgr,
s,
tracer: &*tracer,
target: &target,
thread_id,
progress,
token,
arm_sent: false,
id: None,
last: Counts::default(),
};
match trace.drive(plan, cancel).await {
Ok(run) => {
if let (TraceRun::Done { .. }, Some(id)) = (&run, trace.id) {
*s.stream_trace_done.lock() = Some(DoneTrace { tracer: tracer.clone(), target: target.clone(), id });
}
run
}
Err(run) => {
// A stop from now on is the user's to see.
set_running(s, false);
trace.release().await;
run
}
}
}
/// `None` when no trace runs or it is still arming. The trace itself goes on to report how the
/// abort ended it.
pub(crate) async fn abort(s: &Session) -> IdeResult<Option<AbortState>> {
let (tracer, target, id) = {
let mut slot = s.stream_trace.lock();
let Some(active) = slot.as_mut() else { return Ok(None) };
let Some(id) = active.id else { return Ok(None) };
active.aborting = true;
(active.tracer.clone(), active.target.clone(), id)
};
let result = tokio::select! {
biased;
() = s.ended.cancelled() => return Ok(None),
result = tracer.abort(&target, id) => result,
};
match result {
Ok(state) => Ok(Some(state)),
Err(InspectError::NoTrace) => Ok(None),
Err(e) => Err(IdeError::internal(format!("cannot abort the stream trace: {e}"))),
}
}
#[derive(Default)]
struct Counts {
records: u64,
dropped: u64,
elapsed_ms: u64,
}
struct Trace<'a, P> {
mgr: &'a DebugManager,
s: &'a Session,
tracer: &'a dyn StreamTracer,
/// The stop the trace was armed in.
target: &'a VmTarget,
thread_id: i64,
progress: &'a P,
/// Names the trace to the bundle before `arm` answers (see [`StreamTracer::release_armed`]).
token: String,
arm_sent: bool,
/// Set once `arm` answers.
id: Option<TraceId>,
last: Counts,
}
impl<P: Fn(TraceProgress) + Send + Sync> Trace<'_, P> {
/// `Err` ends the trace early.
async fn drive(&mut self, plan: &Value, cancel: &CancellationToken) -> Result<TraceRun, TraceRun> {
let (s, tracer, target) = (self.s, self.tracer, self.target);
self.report(TracePhase::Arming);
self.arm_sent = true;
let id = self
.until_ended(tracer.arm(target, self.thread_id, plan, BUDGET, &self.token))
.await?
.map_err(|e| if s.ended.is_cancelled() { ended() } else { refused(e) })?;
self.id = Some(id);
if let Some(active) = s.stream_trace.lock().as_mut() {
active.id = Some(id);
}
// Before the request: the thread can stop again before its reply arrives.
set_running(s, true);
self.dap(self.mgr.resume(s.id, self.thread_id)).await?;
let mut stopped = false;
loop {
if cancel.is_cancelled() && !stopped {
stopped = true;
// Refused when the trace parked or failed just before: `wait` reports that.
match self.until_ended(tracer.stop(target, id)).await? {
Ok(records) => {
self.last.records = records;
self.report(TracePhase::RecordingStopped);
}
Err(e) => tracing::debug!(session = s.id.0, trace = id, "stream trace stop: {e}"),
}
}
match self.inspect(tracer.wait(target, id, WAIT_MS)).await? {
TraceState::Running { records, dropped, elapsed_ms } => {
self.last = Counts { records, dropped, elapsed_ms };
let aborting = s.stream_trace.lock().as_ref().is_some_and(|a| a.aborting);
self.report(if aborting {
TracePhase::Aborting
} else if stopped {
TracePhase::RecordingStopped
} else {
TracePhase::Running
});
}
TraceState::Parked { records, dropped } => {
set_running(s, false);
self.last.records = records;
self.last.dropped = dropped;
break;
}
TraceState::Failed { detail } => return Err(TraceRun::Failed { detail }),
TraceState::Cancelled { detail } => return Err(TraceRun::Cancelled { detail }),
}
}
self.report(TracePhase::Collecting);
let before = s.suspended.ticket();
self.dap(self.mgr.step(s.id, self.thread_id, StepKind::Out)).await?;
// Another thread's stop meanwhile is not this one: the traced thread would still be
// inside the terminal operation.
let stop = async {
loop {
if let Some(ticket) = s.suspended.stopped_since(self.thread_id, before) {
return ticket;
}
tokio::time::sleep(STOP_POLL).await;
}
};
let Ok(generation) = self.until_ended(tokio::time::timeout(STOP_WAIT, stop)).await? else {
// Collecting in the old stop would only be refused as stale.
return Err(TraceRun::Failed { detail: step_out_timeout() });
};
let stopped_in = VmTarget { generation, ..vm_target(s) };
let collected = self.inspect(tracer.collect(&stopped_in, id, self.last.records)).await?;
let resumed_stops = s.stream_trace.lock().as_ref().map_or(0, |a| a.resumed_stops);
Ok(TraceRun::Done { collected, generation, resumed_stops })
}
/// After a trace that ended early. Left to the bundle, an armed trace would keep every
/// breakpoint off and a parked one its thread suspended behind java-debug's back; the bundle
/// undoes either, or does so once a terminal still running returns. Not after a finished
/// trace: the records it unpins are the values the result shows ([`release_done`] does, once
/// that stop ends). An `arm` that never answered (it timed out) may still have armed: released
/// by its token.
async fn release(&self) {
if self.s.ended.is_cancelled() {
return;
}
let work = match self.id {
Some(id) => self.tracer.release(self.target, id),
None if self.arm_sent => self.tracer.release_armed(self.target, &self.token),
None => return,
};
if let Ok(Err(e)) = self.until_ended(work).await {
tracing::debug!(session = self.s.id.0, trace = ?self.id, "stream trace release: {e}");
}
}
fn report(&self, phase: TracePhase) {
let Counts { records, dropped, elapsed_ms } = self.last;
(self.progress)(TraceProgress { phase, records, dropped, elapsed_ms });
}
/// A reply may never come once the session ends.
async fn until_ended<T>(&self, work: impl Future<Output = T>) -> Result<T, TraceRun> {
tokio::select! {
biased;
() = self.s.ended.cancelled() => Err(ended()),
value = work => Ok(value),
}
}
async fn inspect<T>(&self, work: InspectFuture<'_, T>) -> Result<T, TraceRun> {
self.until_ended(work).await?.map_err(|e| self.failed(e.to_string()))
}
async fn dap(&self, work: impl Future<Output = IdeResult<()>>) -> Result<(), TraceRun> {
self.until_ended(work).await?.map_err(|e| self.failed(e.message))
}
/// A request that failed because the session was ending says so.
fn failed(&self, detail: String) -> TraceRun {
if self.s.ended.is_cancelled() { ended() } else { TraceRun::Failed { detail } }
}
}
fn step_out_timeout() -> String {
format!(
"java-debug reported no stop within {} s of stepping out of the stream's terminal operation",
STOP_WAIT.as_secs()
)
}
fn ended() -> TraceRun {
TraceRun::Failed { detail: "the debug session ended".into() }
}
fn refused(e: InspectError) -> TraceRun {
use TraceUnavailable as U;
let reason = match e {
InspectError::NotSuspended => U::NotSuspended,
InspectError::Busy => U::Busy,
InspectError::NoSession => U::NoSession,
InspectError::Unsupported(detail) => U::Unsupported { detail },
InspectError::NotAtChainStart(detail) => U::NotAtChainStart { detail },
other => return TraceRun::Failed { detail: other.to_string() },
};
TraceRun::Unavailable { reason }
}
+3 -55
Переглянути файл
@@ -1,7 +1,6 @@
//! Protocol flow against an in-memory fake adapter.
mod jvm_inspect;
mod stream_trace;
use super::*;
use crate::adapter::{AdapterIo, LaunchFuture};
@@ -72,21 +71,10 @@ async fn windows_stop_releases_the_debuggees_port_before_returning() {
.unwrap();
let pid = child.0.id();
child.1 = Some(ide_core::process::ProcessTree::capture(pid));
// A running program: one suspended at a breakpoint is killed at once (#3658), without the
// wait for its tree this test is about.
let h = harness(Script {
debuggee_pid: Some(pid),
supports_terminate,
continued_after_stop: true,
..Default::default()
});
let h = harness(Script { debuggee_pid: Some(pid), supports_terminate, ..Default::default() });
let id = h.start(config()).await.unwrap();
let session = h.manager.session(id).unwrap();
// The pid, then the stop at launch and the `continued` that ends it.
while session.debuggee_pid.load(Ordering::Acquire) != i64::from(pid)
|| session.suspended.ticket() == 0
|| session.suspended.get()
{
while session.debuggee_pid.load(Ordering::Acquire) != i64::from(pid) {
tokio::time::sleep(Duration::from_millis(10)).await;
}
let stop = tokio::spawn({
@@ -144,16 +132,6 @@ struct Script {
continue_reply: Option<Value>,
/// Answer `continue` and stop at a breakpoint again, instead of letting the program exit.
stop_after_continue: bool,
/// Answer `stepOut` and stop these threads one after the other, 100 ms apart (java-debug
/// stops the stepping thread right after the call returns).
step_out_stops: &'static [i64],
/// Refuse `stepOut`.
refuse_step_out: bool,
/// Refuse `continue`.
refuse_continue: bool,
/// Stop thread 1 alone at a breakpoint right after each of the first this many `continue`s
/// that `continue_reply` answers.
breakpoints_after_continue: usize,
/// The `reason` of the stop a `next` ends with (`step` when unset; kotlin-lsp says `breakpoint`).
step_reason: Option<&'static str>,
/// Refuse `next`, then stop at a breakpoint (one the program hit meanwhile).
@@ -207,10 +185,6 @@ impl Default for Script {
hang_up_after_stop: false,
continue_reply: None,
stop_after_continue: false,
step_out_stops: &[],
refuse_step_out: false,
refuse_continue: false,
breakpoints_after_continue: 0,
step_reason: None,
refuse_next: false,
invalidated_after_stop: false,
@@ -274,7 +248,6 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
let mut running = false;
let mut thread_requests = 0;
let mut unity = false;
let mut breakpoints_left = script.breakpoints_after_continue;
macro_rules! send {
($v:expr) => {{
let mut v: Value = $v;
@@ -521,21 +494,7 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
{"label": ""},
]})
),
"continue" if script.refuse_continue => send!(
json!({"type": "response", "request_seq": msg["seq"], "command": "continue", "success": false, "message": "Thread is not suspended"})
),
"continue" if script.continue_reply.is_some() => {
ok!(msg, script.continue_reply.clone().unwrap());
if breakpoints_left > 0 {
breakpoints_left -= 1;
send!(
json!({"type": "event", "event": "stopped", "body": {"reason": "breakpoint", "threadId": 1}})
);
}
}
"stepOut" if script.refuse_step_out => send!(
json!({"type": "response", "request_seq": msg["seq"], "command": "stepOut", "success": false, "message": "Thread is not suspended"})
),
"continue" if script.continue_reply.is_some() => ok!(msg, script.continue_reply.clone().unwrap()),
"continue" if script.stop_after_continue => {
ok!(msg, json!({"allThreadsContinued": true}));
send!(
@@ -548,16 +507,6 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
send!(json!({"type": "event", "event": "terminated"}));
}
"pause" if script.hang_up_on_pause => break,
"stepOut" if !script.step_out_stops.is_empty() => {
ok!(msg, Value::Null);
for (i, thread) in script.step_out_stops.iter().enumerate() {
if i > 0 {
tokio::time::sleep(Duration::from_millis(100)).await;
}
let reason = if i + 1 == script.step_out_stops.len() { "step" } else { "breakpoint" };
send!(json!({"type": "event", "event": "stopped", "body": {"reason": reason, "threadId": thread}}));
}
}
"stepIn" | "stepOut" | "pause" => ok!(msg, Value::Null),
"redefineClasses" => {
send!(
@@ -1922,7 +1871,6 @@ fn godot_registry(port: u16, command: &str, args: &[&str]) -> Arc<LanguageRegist
framework_files: Vec::new(),
formatter: None,
scratch_template: None,
rainbow_brackets: Default::default(),
tree_sitter: None,
language_servers: vec![],
debugger: Some(ide_language::DebuggerConfig {
-558
Переглянути файл
@@ -1,558 +0,0 @@
//! A stream chain traced while the program runs it, through a session's stream tracer.
use super::*;
use ide_core::CancellationToken;
use ide_jvm_inspect::{
AbortState, CollectedTerminal, InspectError, InspectFuture, JvmValue, StreamTracer, TraceCollected, TraceId,
TraceState, VmTarget,
};
use std::collections::VecDeque;
use tokio::sync::Notify;
const TRACE: TraceId = 7;
#[derive(Default)]
struct FakeTracer {
/// Answers to `wait`, in order. Once they run out, `wait` signals `waiting` and answers only
/// after more are pushed and `more` is notified.
waits: Mutex<VecDeque<Result<TraceState, InspectError>>>,
arm_error: Mutex<Option<InspectError>>,
stop_error: Mutex<Option<InspectError>>,
collect_error: Mutex<Option<InspectError>>,
/// The record count each `collect` was given.
collect_records: Mutex<Vec<u64>>,
calls: Mutex<Vec<(&'static str, VmTarget)>>,
waiting: Notify,
more: Notify,
}
impl FakeTracer {
fn scripted(waits: impl IntoIterator<Item = TraceState>) -> Arc<Self> {
Self::answering(waits.into_iter().map(Ok))
}
fn answering(waits: impl IntoIterator<Item = Result<TraceState, InspectError>>) -> Arc<Self> {
Arc::new(Self { waits: Mutex::new(waits.into_iter().collect()), ..Self::default() })
}
fn record(&self, name: &'static str, target: &VmTarget) {
self.calls.lock().push((name, target.clone()));
}
fn names(&self) -> Vec<&'static str> {
self.calls.lock().iter().map(|(name, _)| *name).collect()
}
fn target_of(&self, name: &str) -> VmTarget {
self.calls.lock().iter().find(|(n, _)| *n == name).map(|(_, t)| t.clone()).unwrap()
}
}
impl StreamTracer for FakeTracer {
fn arm<'a>(
&'a self,
target: &'a VmTarget,
_thread_id: i64,
_plan: &'a Value,
_budget: u32,
_token: &'a str,
) -> InspectFuture<'a, TraceId> {
self.record("arm", target);
let error = self.arm_error.lock().clone();
Box::pin(async move { error.map_or(Ok(TRACE), Err) })
}
fn wait<'a>(&'a self, target: &'a VmTarget, _trace: TraceId, _ms: u32) -> InspectFuture<'a, TraceState> {
self.record("wait", target);
Box::pin(async move {
loop {
if let Some(state) = self.waits.lock().pop_front() {
return state;
}
self.waiting.notify_one();
self.more.notified().await;
}
})
}
fn stop<'a>(&'a self, target: &'a VmTarget, _trace: TraceId) -> InspectFuture<'a, u64> {
self.record("stop", target);
let error = self.stop_error.lock().clone();
Box::pin(async move { error.map_or(Ok(3), Err) })
}
fn abort<'a>(&'a self, target: &'a VmTarget, _trace: TraceId) -> InspectFuture<'a, AbortState> {
self.record("abort", target);
Box::pin(async { Ok(AbortState::Interrupted) })
}
fn collect<'a>(&'a self, target: &'a VmTarget, _trace: TraceId, records: u64) -> InspectFuture<'a, TraceCollected> {
self.record("collect", target);
self.collect_records.lock().push(records);
let error = self.collect_error.lock().clone();
Box::pin(async move { error.map_or_else(|| Ok(collected()), Err) })
}
fn release<'a>(&'a self, target: &'a VmTarget, _trace: TraceId) -> InspectFuture<'a, ()> {
self.record("release", target);
Box::pin(async { Ok(()) })
}
fn release_armed<'a>(&'a self, target: &'a VmTarget, _token: &'a str) -> InspectFuture<'a, ()> {
self.record("releaseArmed", target);
Box::pin(async { Ok(()) })
}
}
fn collected() -> TraceCollected {
TraceCollected {
records: vec![(0, JvmValue::Primitive { type_name: "int".into(), text: "1".into() })],
dropped: 0,
terminal: CollectedTerminal::Void,
skipped_breakpoints: 0,
sequentialized: false,
}
}
fn running(records: u64) -> TraceState {
TraceState::Running { records, dropped: 0, elapsed_ms: 5 }
}
fn parked() -> TraceState {
TraceState::Parked { records: 10, dropped: 0 }
}
/// java-debug keeps the program running after `continue` and stops right after a `stepOut`.
fn java_debug() -> Script {
Script { continue_reply: Some(json!({"allThreadsContinued": true})), step_out_stops: &[1], ..Script::default() }
}
async fn stopped_java(h: &Harness, tracer: &Arc<FakeTracer>) -> DebugSessionId {
let id = h.start(java_config("launch")).await.unwrap();
h.wait_event(|e| matches!(e, DebugEvent::Stopped { .. })).await;
h.manager.set_stream_tracer(id, tracer.clone()).unwrap();
id
}
async fn trace(h: &Harness, id: DebugSessionId) -> IdeResult<TraceRun> {
let run = h.manager.stream_trace(id, 1, json!({"steps": []}), CancellationToken::new(), |_| {});
tokio::time::timeout(Duration::from_secs(10), run).await.expect("the trace did not end")
}
/// A trace in its own task, returned once it waits for the answers its tracer has not got.
async fn hanging_trace(
h: &Harness,
id: DebugSessionId,
tracer: &FakeTracer,
) -> tokio::task::JoinHandle<IdeResult<TraceRun>> {
hanging_trace_with(h, id, tracer, |_| {}).await
}
async fn hanging_trace_with(
h: &Harness,
id: DebugSessionId,
tracer: &FakeTracer,
progress: impl Fn(TraceProgress) + Send + Sync + 'static,
) -> tokio::task::JoinHandle<IdeResult<TraceRun>> {
let manager = h.manager.clone();
let task = tokio::spawn(async move {
manager.stream_trace(id, 1, json!({"steps": []}), CancellationToken::new(), progress).await
});
tokio::time::timeout(Duration::from_secs(5), tracer.waiting.notified()).await.expect("the trace did not wait");
task
}
fn phases(seen: &Mutex<Vec<TraceProgress>>) -> Vec<TracePhase> {
seen.lock().iter().map(|p| p.phase).collect()
}
fn progress(phase: TracePhase, records: u64, elapsed_ms: u64) -> TraceProgress {
TraceProgress { phase, records, dropped: 0, elapsed_ms }
}
#[tokio::test]
async fn trace_runs_continue_then_step_out() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([running(10), parked()]);
let id = stopped_java(&h, &tracer).await;
let start = h.manager.session(id).unwrap().suspended.ticket();
let run = trace(&h, id).await.unwrap();
let TraceRun::Done { collected: got, generation, resumed_stops } = run else { panic!("not done: {run:?}") };
assert_eq!(got, collected());
assert_eq!(resumed_stops, 0);
assert!(generation > start, "collected in the stop of the trace ({start}), not after it ({generation})");
let commands = h.commands();
let resumed = commands.iter().position(|c| c == "continue").expect("no continue");
let stepped = commands.iter().position(|c| c == "stepOut").expect("no stepOut");
assert!(resumed < stepped, "{commands:?}");
assert_eq!(h.request("continue")["arguments"]["threadId"], 1);
assert_eq!(h.request("stepOut")["arguments"]["threadId"], 1);
assert_eq!(tracer.names(), ["arm", "wait", "wait", "collect"]);
assert_eq!(*tracer.collect_records.lock(), [10], "collect is told how many records the trace parked with");
assert_eq!(tracer.target_of("arm").generation, start);
assert_eq!(tracer.target_of("collect").generation, generation);
assert!(h.manager.session(id).unwrap().suspended.get());
}
#[tokio::test]
async fn trace_reports_progress() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([running(10), parked()]);
let id = stopped_java(&h, &tracer).await;
let seen: Arc<Mutex<Vec<TraceProgress>>> = Arc::default();
let sink = seen.clone();
let run = h.manager.stream_trace(id, 1, json!({}), CancellationToken::new(), move |p| sink.lock().push(p)).await;
assert!(matches!(run, Ok(TraceRun::Done { .. })), "{run:?}");
assert_eq!(
*seen.lock(),
[
progress(TracePhase::Arming, 0, 0),
progress(TracePhase::Running, 10, 5),
progress(TracePhase::Collecting, 10, 5),
]
);
}
#[tokio::test]
async fn cancel_stops_recording_once() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([running(10), running(12), parked()]);
let id = stopped_java(&h, &tracer).await;
let cancel = CancellationToken::new();
let on_running = cancel.clone();
let seen: Arc<Mutex<Vec<TracePhase>>> = Arc::default();
let sink = seen.clone();
let run = h
.manager
.stream_trace(id, 1, json!({}), cancel, move |p| {
if p.phase == TracePhase::Running {
on_running.cancel();
}
sink.lock().push(p.phase);
})
.await;
assert!(matches!(run, Ok(TraceRun::Done { .. })), "{run:?}");
assert_eq!(tracer.names(), ["arm", "wait", "stop", "wait", "wait", "collect"]);
assert_eq!(
*seen.lock(),
[
TracePhase::Arming,
TracePhase::Running,
TracePhase::RecordingStopped,
TracePhase::RecordingStopped,
TracePhase::Collecting
]
);
}
#[tokio::test]
async fn second_trace_is_busy() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
let first = hanging_trace(&h, id, &tracer).await;
let second = trace(&h, id).await.unwrap();
assert_eq!(second, TraceRun::Unavailable { reason: TraceUnavailable::Busy });
assert_eq!(tracer.names().iter().filter(|n| **n == "arm").count(), 1);
first.abort();
}
#[tokio::test]
async fn trace_ends_when_session_ends() {
// The fake adapter lets the program exit on `continue`.
let h = harness(Script::default());
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
let session = h.manager.session(id).unwrap();
let run = trace(&h, id).await.unwrap();
assert_eq!(run, TraceRun::Failed { detail: "the debug session ended".into() });
assert!(session.stream_trace.lock().is_none());
let next = trace(&h, id).await;
assert!(!matches!(next, Ok(TraceRun::Unavailable { reason: TraceUnavailable::Busy })), "{next:?}");
}
#[tokio::test]
async fn dropping_the_trace_frees_the_session() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
let first = hanging_trace(&h, id, &tracer).await;
first.abort();
assert!(first.await.unwrap_err().is_cancelled());
let session = h.manager.session(id).unwrap();
assert!(session.stream_trace.lock().is_none());
// The first trace resumed the thread.
session.suspended.stopped(Some(1), false);
let again = hanging_trace(&h, id, &tracer).await;
assert_eq!(tracer.names().iter().filter(|n| **n == "arm").count(), 2);
again.abort();
}
#[tokio::test]
async fn arm_errors_map_to_unavailable_or_failed() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
*tracer.arm_error.lock() = Some(InspectError::NotAtChainStart("the stop is on line 4".into()));
assert_eq!(
trace(&h, id).await.unwrap(),
TraceRun::Unavailable { reason: TraceUnavailable::NotAtChainStart { detail: "the stop is on line 4".into() } }
);
*tracer.arm_error.lock() = Some(InspectError::TimedOut);
assert_eq!(trace(&h, id).await.unwrap(), TraceRun::Failed { detail: InspectError::TimedOut.to_string() });
assert!(!h.commands().iter().any(|c| c == "continue"));
}
#[tokio::test]
async fn abort_reaches_the_running_trace() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
assert_eq!(h.manager.stream_trace_abort(id).await.unwrap(), None);
let seen: Arc<Mutex<Vec<TraceProgress>>> = Arc::default();
let sink = seen.clone();
let task = hanging_trace_with(&h, id, &tracer, move |p| sink.lock().push(p)).await;
assert_eq!(h.manager.stream_trace_abort(id).await.unwrap(), Some(AbortState::Interrupted));
assert_eq!(tracer.target_of("abort"), tracer.target_of("arm"));
let thrown = "java.lang.RuntimeException: oi-cancel:1";
tracer.waits.lock().extend([Ok(running(4)), Ok(TraceState::Failed { detail: thrown.into() })]);
tracer.more.notify_one();
let run = tokio::time::timeout(Duration::from_secs(5), task).await.unwrap().unwrap().unwrap();
assert_eq!(run, TraceRun::Failed { detail: thrown.into() });
assert_eq!(phases(&seen), [TracePhase::Arming, TracePhase::Aborting]);
assert_eq!(tracer.names().last(), Some(&"release"));
}
#[tokio::test]
async fn failed_wait_passes_its_detail_through() {
let h = harness(java_debug());
let detail = "the program began to exit while the stream ran: stop the debug session";
let tracer = FakeTracer::scripted([running(1), TraceState::Failed { detail: detail.into() }]);
let id = stopped_java(&h, &tracer).await;
assert_eq!(trace(&h, id).await.unwrap(), TraceRun::Failed { detail: detail.into() });
assert_eq!(tracer.names(), ["arm", "wait", "wait", "release"]);
assert!(!h.commands().iter().any(|c| c == "stepOut"));
}
#[tokio::test]
async fn a_trace_cancelled_before_its_terminal_says_so() {
let detail = "cancelled before the terminal ran";
let tracer = FakeTracer::scripted([TraceState::Cancelled { detail: detail.into() }]);
let h = harness(java_debug());
let id = stopped_java(&h, &tracer).await;
assert_eq!(trace(&h, id).await.unwrap(), TraceRun::Cancelled { detail: detail.into() });
assert!(!h.commands().iter().any(|c| c == "stepOut"));
}
#[tokio::test]
async fn a_wait_that_errs_releases_the_trace() {
let h = harness(java_debug());
let tracer = FakeTracer::answering([Ok(running(1)), Err(InspectError::TimedOut)]);
let id = stopped_java(&h, &tracer).await;
assert_eq!(trace(&h, id).await.unwrap(), TraceRun::Failed { detail: InspectError::TimedOut.to_string() });
assert_eq!(tracer.names(), ["arm", "wait", "wait", "release"]);
assert_eq!(tracer.target_of("release"), tracer.target_of("arm"));
}
#[tokio::test]
async fn a_refused_step_out_releases_the_trace() {
let h = harness(Script { refuse_step_out: true, ..java_debug() });
let tracer = FakeTracer::scripted([parked()]);
let id = stopped_java(&h, &tracer).await;
let run = trace(&h, id).await.unwrap();
assert!(matches!(&run, TraceRun::Failed { detail } if detail.contains("not suspended")), "{run:?}");
assert_eq!(tracer.names(), ["arm", "wait", "release"]);
}
#[tokio::test]
async fn a_refused_continue_releases_the_trace() {
let h = harness(Script { refuse_continue: true, ..java_debug() });
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
let run = trace(&h, id).await.unwrap();
assert!(matches!(&run, TraceRun::Failed { .. }), "{run:?}");
assert_eq!(tracer.names(), ["arm", "release"]);
}
#[tokio::test]
async fn a_failed_collect_releases_the_trace() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([parked()]);
*tracer.collect_error.lock() = Some(InspectError::Stale);
let id = stopped_java(&h, &tracer).await;
assert!(matches!(trace(&h, id).await.unwrap(), TraceRun::Failed { .. }));
assert_eq!(tracer.names(), ["arm", "wait", "collect", "release"]);
}
fn stops(h: &Harness) -> usize {
h.events.lock().iter().filter(|e| matches!(e, IdeEvent::Debug { event: DebugEvent::Stopped { .. }, .. })).count()
}
#[tokio::test]
async fn a_stop_of_the_traced_thread_while_the_chain_runs_is_resumed_unseen() {
// A breakpoint java-debug set meanwhile, hit inside the terminal's invoke before the bundle
// switched it off: held there, the invoke would never return.
let h = harness(Script { breakpoints_after_continue: 1, ..java_debug() });
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
let shown = stops(&h);
let task = hanging_trace(&h, id, &tracer).await;
for _ in 0..200 {
if h.commands().iter().filter(|c| *c == "continue").count() == 2 {
break;
}
tokio::time::sleep(Duration::from_millis(10)).await;
}
assert_eq!(h.commands().iter().filter(|c| *c == "continue").count(), 2, "{:?}", h.commands());
assert_eq!(h.log.lock().iter().rfind(|m| m["command"] == "continue").unwrap()["arguments"]["threadId"], 1);
tracer.waits.lock().push_back(Ok(parked()));
tracer.more.notify_one();
let run = tokio::time::timeout(Duration::from_secs(5), task).await.unwrap().unwrap().unwrap();
let TraceRun::Done { resumed_stops, .. } = run else { panic!("not done: {run:?}") };
assert_eq!(resumed_stops, 1);
assert_eq!(stops(&h), shown + 1, "only the step-out stop is shown, after the trace parked");
}
#[tokio::test]
async fn a_finished_trace_is_not_released() {
// Releasing unpins the records, which the result's values still show until the program runs on.
let h = harness(java_debug());
let tracer = FakeTracer::scripted([parked()]);
let id = stopped_java(&h, &tracer).await;
assert!(matches!(trace(&h, id).await.unwrap(), TraceRun::Done { .. }));
assert!(!tracer.names().contains(&"release"), "{:?}", tracer.names());
}
#[tokio::test]
async fn a_finished_trace_is_released_once_the_program_runs_on() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([parked()]);
let id = stopped_java(&h, &tracer).await;
assert!(matches!(trace(&h, id).await.unwrap(), TraceRun::Done { .. }));
h.manager.resume(id, 1).await.unwrap();
tokio::time::timeout(Duration::from_secs(5), async {
while !tracer.names().contains(&"release") {
tokio::time::sleep(Duration::from_millis(10)).await;
}
})
.await
.expect("the finished trace was not released");
assert_eq!(tracer.names().iter().filter(|n| **n == "release").count(), 1);
}
#[tokio::test]
async fn an_arm_without_a_reply_is_released_by_its_token() {
// The bundle may still finish arming after the reply timed out: its breakpoints would stay off.
let h = harness(java_debug());
let tracer = FakeTracer::scripted([]);
let id = stopped_java(&h, &tracer).await;
*tracer.arm_error.lock() = Some(InspectError::TimedOut);
assert!(matches!(trace(&h, id).await.unwrap(), TraceRun::Failed { .. }));
assert_eq!(tracer.names(), ["arm", "releaseArmed"]);
}
#[tokio::test]
async fn refused_stop_leaves_the_outcome_to_wait() {
let h = harness(java_debug());
let tracer = FakeTracer::scripted([running(10), parked()]);
*tracer.stop_error.lock() = Some(InspectError::NoTrace);
let id = stopped_java(&h, &tracer).await;
let cancel = CancellationToken::new();
let on_running = cancel.clone();
let seen: Arc<Mutex<Vec<TraceProgress>>> = Arc::default();
let sink = seen.clone();
let run = h
.manager
.stream_trace(id, 1, json!({}), cancel, move |p| {
if p.phase == TracePhase::Running {
on_running.cancel();
}
sink.lock().push(p);
})
.await;
assert!(matches!(run, Ok(TraceRun::Done { .. })), "{run:?}");
assert_eq!(tracer.names(), ["arm", "wait", "stop", "wait", "collect"]);
assert_eq!(phases(&seen), [TracePhase::Arming, TracePhase::Running, TracePhase::Collecting]);
}
#[tokio::test]
async fn another_threads_stop_is_not_the_step_out() {
// Thread 2 stops at a breakpoint 100 ms before the traced thread's step out ends.
let h = harness(Script { step_out_stops: &[2, 1], ..java_debug() });
let tracer = FakeTracer::scripted([parked()]);
let id = stopped_java(&h, &tracer).await;
let start = h.manager.session(id).unwrap().suspended.ticket();
let run = trace(&h, id).await.unwrap();
let TraceRun::Done { generation, .. } = run else { panic!("not done: {run:?}") };
assert_eq!(
generation,
start + 2,
"collected in thread 2's stop, not in the traced thread's step-out stop after it"
);
assert_eq!(tracer.target_of("collect").generation, generation);
}
#[tokio::test]
async fn step_out_without_a_stop_times_out() {
let h = harness(Script { step_out_stops: &[], ..java_debug() });
let tracer = FakeTracer::scripted([parked()]);
let id = stopped_java(&h, &tracer).await;
tokio::time::pause();
let run = h.manager.stream_trace(id, 1, json!({}), CancellationToken::new(), |_| {}).await.unwrap();
assert_eq!(
run,
TraceRun::Failed {
detail: "java-debug reported no stop within 30 s of stepping out of the stream's terminal operation".into()
}
);
assert!(h.commands().iter().any(|c| c == "stepOut"));
assert_eq!(tracer.names(), ["arm", "wait", "release"]);
}
#[tokio::test]
async fn capability_only_for_java_debug() {
let h = harness(Script::default());
let tracer = FakeTracer::scripted([]);
let java = h.start(java_config("launch")).await.unwrap();
assert!(!h.manager.capabilities(java).unwrap().stream_trace);
h.manager.set_stream_tracer(java, tracer.clone()).unwrap();
assert!(h.manager.capabilities(java).unwrap().stream_trace);
let other = h.start(config()).await.unwrap();
h.manager.set_stream_tracer(other, tracer.clone()).unwrap();
assert!(!h.manager.capabilities(other).unwrap().stream_trace);
}
-51
Переглянути файл
@@ -14,7 +14,6 @@ mod snowflake;
pub mod source;
pub mod split;
pub mod sql;
pub mod tools;
mod watch;
pub use watch::SourcesWatch;
@@ -788,56 +787,6 @@ impl DbManager {
Ok(v.unwrap_or_else(|| "Connected".into()))
}
/// Runs `job` with the client tool at `executable` against target `id`, connected like the
/// data source (through its SSH tunnel, with its SSL settings and password), until it exits
/// or `cancel` fires. Connects first, so a missing password fails the way it does for a
/// console. Returns the exit code.
pub async fn run_tool(
&self,
id: &str,
executable: &std::path::Path,
job: &tools::DbToolJob,
cancel: &CancellationToken,
on_output: impl FnMut(Vec<tools::ToolLine>),
) -> IdeResult<Option<i32>> {
let tool = job.tool();
if !tool.is_program(executable) {
return Err(IdeError::invalid(format!("{} is not {}", executable.display(), tool.program())));
}
let source = self.source(id)?;
if source.driver != tool.driver() {
return Err(IdeError::invalid(format!("{} cannot connect to {}", tool.program(), source.name)));
}
self.pool(id).await?;
let password = self.password(&source).await;
// Holding the tunnel keeps it open while the tool runs, even if the tree disconnects.
let (target, _tunnel) = self.endpoint(&source, None, true).await?;
let prepared = tools::prepare(job, &target, password.as_deref());
tools::run(executable, &prepared.args, &prepared.env, cancel, on_output).await
}
/// The command [`DbManager::run_tool`] would run, for the dialogs' preview: the data source's
/// own host and port (not a tunnel's local end), and no password.
pub fn tool_preview(&self, id: &str, executable: &std::path::Path, job: &tools::DbToolJob) -> IdeResult<String> {
let source = self.source(id)?;
let prepared = tools::prepare(job, &source, None);
Ok(tools::command_line(executable, &prepared.args))
}
/// The PostgreSQL server's `server_version_num` (`150013` for 15.13).
pub async fn server_version(&self, id: &str) -> IdeResult<u32> {
let pool = self.pool(id).await?;
if pool.driver() != DbDriver::Postgres {
return Err(IdeError::invalid("not a PostgreSQL data source"));
}
let rows = pool.rows("SHOW server_version_num", 1).await?;
rows.into_iter()
.next()
.and_then(|r| r.into_iter().next().flatten())
.and_then(|v| v.trim().parse().ok())
.ok_or_else(|| IdeError::internal("no server version"))
}
pub fn is_connected(&self, id: &str) -> bool {
self.pools.lock().contains_key(id)
}
-341
Переглянути файл
@@ -1,341 +0,0 @@
//! What a dump or restore dialog asks for, as typed options, and the arguments that do it.
//! The connection arguments come from [`super::connection`]; these are the rest.
use super::DbTool;
use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::Path;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum DbDumpFormat {
/// SQL text, restored with `psql`.
Plain,
Custom,
/// A directory of files; the only format `pg_dump` writes in parallel.
Directory,
Tar,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum DbDumpStatements {
Copy,
Inserts,
ColumnInserts,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum DbDumpContent {
All,
SchemaOnly,
DataOnly,
}
/// Name lists hold `pg_dump` patterns (`*`, `?`, quoted names).
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DbPgDumpOptions {
pub format: DbDumpFormat,
pub statements: DbDumpStatements,
pub content: DbDumpContent,
pub schemas: Vec<String>,
pub tables: Vec<String>,
pub exclude_tables: Vec<String>,
/// Plain format only: archives get DROP / CREATE at restore.
pub clean: bool,
pub if_exists: bool,
pub create: bool,
pub no_owner: bool,
pub no_privileges: bool,
/// Directory format only.
pub jobs: u32,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DbPgRestoreOptions {
pub content: DbDumpContent,
pub schemas: Vec<String>,
pub clean: bool,
pub if_exists: bool,
pub no_owner: bool,
pub no_privileges: bool,
pub single_transaction: bool,
pub exit_on_error: bool,
/// Ignored with a single transaction, which `pg_restore` cannot split.
pub jobs: u32,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct DbPsqlOptions {
pub single_transaction: bool,
pub stop_on_error: bool,
}
/// A run of a client tool: which one, the file it writes or reads, and its options.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "tool", rename_all = "camelCase")]
pub enum DbToolJob {
PgDump {
file: String,
options: DbPgDumpOptions,
},
/// `file`: an archive, or a directory archive.
PgRestore {
file: String,
options: DbPgRestoreOptions,
},
Psql {
file: String,
options: DbPsqlOptions,
},
}
impl DbToolJob {
pub fn tool(&self) -> DbTool {
match self {
DbToolJob::PgDump { .. } => DbTool::PgDump,
DbToolJob::PgRestore { .. } => DbTool::PgRestore,
DbToolJob::Psql { .. } => DbTool::Psql,
}
}
/// The arguments after the connection ones.
pub fn args(&self) -> Vec<String> {
match self {
DbToolJob::PgDump { file, options } => pg_dump(options, file),
DbToolJob::PgRestore { file, options } => pg_restore(options, file),
DbToolJob::Psql { file, options } => psql(options, file),
}
}
}
fn flag(on: bool, flag: &str) -> Option<String> {
on.then(|| flag.to_owned())
}
fn content(c: DbDumpContent) -> Option<String> {
match c {
DbDumpContent::All => None,
DbDumpContent::SchemaOnly => Some("--schema-only".into()),
DbDumpContent::DataOnly => Some("--data-only".into()),
}
}
fn each(names: &[String], option: &str) -> impl Iterator<Item = String> {
names.iter().map(|n| n.trim()).filter(|n| !n.is_empty()).map(move |n| format!("--{option}={n}"))
}
fn pg_dump(o: &DbPgDumpOptions, file: &str) -> Vec<String> {
let plain = o.format == DbDumpFormat::Plain;
let format = match o.format {
DbDumpFormat::Plain => "p",
DbDumpFormat::Custom => "c",
DbDumpFormat::Directory => "d",
DbDumpFormat::Tar => "t",
};
let mut args = vec![format!("--format={format}"), format!("--file={file}")];
args.extend(match o.statements {
DbDumpStatements::Copy => None,
DbDumpStatements::Inserts => Some("--inserts".to_owned()),
DbDumpStatements::ColumnInserts => Some("--column-inserts".to_owned()),
});
args.extend(content(o.content));
args.extend(each(&o.schemas, "schema"));
args.extend(each(&o.tables, "table"));
args.extend(each(&o.exclude_tables, "exclude-table"));
args.extend(flag(plain && o.clean, "--clean"));
args.extend(flag(plain && o.clean && o.if_exists, "--if-exists"));
args.extend(flag(plain && o.create, "--create"));
args.extend(flag(o.no_owner, "--no-owner"));
args.extend(flag(o.no_privileges, "--no-privileges"));
if o.format == DbDumpFormat::Directory && o.jobs > 1 {
args.push(format!("--jobs={}", o.jobs));
}
args.push("--verbose".into());
args
}
fn pg_restore(o: &DbPgRestoreOptions, file: &str) -> Vec<String> {
let mut args: Vec<String> = content(o.content).into_iter().collect();
args.extend(each(&o.schemas, "schema"));
args.extend(flag(o.clean, "--clean"));
args.extend(flag(o.clean && o.if_exists, "--if-exists"));
args.extend(flag(o.no_owner, "--no-owner"));
args.extend(flag(o.no_privileges, "--no-privileges"));
args.extend(flag(o.single_transaction, "--single-transaction"));
args.extend(flag(o.exit_on_error, "--exit-on-error"));
if o.jobs > 1 && !o.single_transaction {
args.push(format!("--jobs={}", o.jobs));
}
args.push("--verbose".into());
if !file.is_empty() {
args.push(file.to_owned());
}
args
}
fn psql(o: &DbPsqlOptions, file: &str) -> Vec<String> {
// `~/.psqlrc` could switch databases or change settings before the dump runs.
let mut args = vec!["--no-psqlrc".to_owned()];
args.extend((!file.is_empty()).then(|| format!("--file={file}")));
args.extend(flag(o.single_transaction, "--single-transaction"));
args.extend(flag(o.stop_on_error, "--set=ON_ERROR_STOP=1"));
args
}
/// The command as a shell would need it typed: the dialogs' preview.
pub fn command_line(program: &Path, args: &[String]) -> String {
let quote = |s: &str| {
if !s.is_empty() && s.chars().all(|c| c.is_ascii_alphanumeric() || "@%+=:,./-_".contains(c)) {
s.to_owned()
} else {
format!("'{}'", s.replace('\'', "'\\''"))
}
};
std::iter::once(program.to_string_lossy().into_owned())
.chain(args.iter().cloned())
.map(|a| quote(&a))
.collect::<Vec<_>>()
.join(" ")
}
#[cfg(test)]
mod tests {
use super::*;
fn dump() -> DbPgDumpOptions {
DbPgDumpOptions {
format: DbDumpFormat::Plain,
statements: DbDumpStatements::Copy,
content: DbDumpContent::All,
schemas: vec![],
tables: vec![],
exclude_tables: vec![],
clean: false,
if_exists: false,
create: false,
no_owner: false,
no_privileges: false,
jobs: 1,
}
}
fn restore() -> DbPgRestoreOptions {
DbPgRestoreOptions {
content: DbDumpContent::All,
schemas: vec![],
clean: false,
if_exists: false,
no_owner: false,
no_privileges: false,
single_transaction: false,
exit_on_error: true,
jobs: 1,
}
}
fn args(job: DbToolJob) -> Vec<String> {
job.args()
}
#[test]
fn dumps_plain_sql_with_copy_by_default() {
let job = DbToolJob::PgDump { file: "/tmp/shop.sql".into(), options: dump() };
assert_eq!(args(job), ["--format=p", "--file=/tmp/shop.sql", "--verbose"]);
}
#[test]
fn turns_lists_and_switches_into_flags() {
let options = DbPgDumpOptions {
statements: DbDumpStatements::ColumnInserts,
content: DbDumpContent::DataOnly,
schemas: vec!["public".into(), "audit".into()],
tables: vec!["public.orders".into()],
exclude_tables: vec!["public.log_*".into()],
clean: true,
if_exists: true,
create: true,
no_owner: true,
..dump()
};
assert_eq!(
args(DbToolJob::PgDump { file: "/tmp/x.sql".into(), options }),
[
"--format=p",
"--file=/tmp/x.sql",
"--column-inserts",
"--data-only",
"--schema=public",
"--schema=audit",
"--table=public.orders",
"--exclude-table=public.log_*",
"--clean",
"--if-exists",
"--create",
"--no-owner",
"--verbose",
]
);
}
#[test]
fn leaves_drop_and_create_to_the_restore_of_an_archive() {
let options = DbPgDumpOptions { format: DbDumpFormat::Custom, clean: true, create: true, ..dump() };
let a = args(DbToolJob::PgDump { file: "/tmp/x.dump".into(), options });
assert!(!a.iter().any(|a| a == "--clean" || a == "--create"), "{a:?}");
}
#[test]
fn runs_parallel_jobs_only_where_the_tool_can() {
let dir = DbPgDumpOptions { format: DbDumpFormat::Directory, jobs: 4, ..dump() };
assert!(args(DbToolJob::PgDump { file: "/tmp/d".into(), options: dir.clone() }).contains(&"--jobs=4".into()));
let custom = DbPgDumpOptions { format: DbDumpFormat::Custom, ..dir };
assert!(!args(DbToolJob::PgDump { file: "/tmp/d".into(), options: custom }).contains(&"--jobs=4".into()));
let single = DbPgRestoreOptions { jobs: 4, single_transaction: true, ..restore() };
let a = args(DbToolJob::PgRestore { file: "/tmp/x".into(), options: single });
assert!(a.contains(&"--single-transaction".into()) && !a.iter().any(|a| a.starts_with("--jobs")));
}
#[test]
fn restores_the_archive_named_last_and_stops_on_the_first_error() {
assert_eq!(
args(DbToolJob::PgRestore { file: "/tmp/shop.dump".into(), options: restore() }),
["--exit-on-error", "--verbose", "/tmp/shop.dump"]
);
}
#[test]
fn leaves_out_an_archive_not_chosen_yet() {
let a = args(DbToolJob::PgRestore { file: String::new(), options: restore() });
assert_eq!(a, ["--exit-on-error", "--verbose"]);
}
#[test]
fn runs_a_sql_file_in_one_transaction_that_stops_on_error() {
let options = DbPsqlOptions { single_transaction: true, stop_on_error: true };
assert_eq!(
args(DbToolJob::Psql { file: "/tmp/shop.sql".into(), options }),
["--no-psqlrc", "--file=/tmp/shop.sql", "--single-transaction", "--set=ON_ERROR_STOP=1"]
);
}
#[test]
fn quotes_what_a_shell_would_split() {
let line = command_line(
Path::new("/usr/bin/pg_dump"),
&["--port=5432".into(), "--file=/tmp/my dump.sql".into(), "--table=it's".into()],
);
assert_eq!(line, r#"/usr/bin/pg_dump --port=5432 '--file=/tmp/my dump.sql' '--table=it'\''s'"#);
}
#[test]
fn reads_the_job_the_dialog_sends() {
let json = r#"{"tool":"psql","file":"/tmp/a.sql","options":{"singleTransaction":true,"stopOnError":false}}"#;
let job: DbToolJob = serde_json::from_str(json).unwrap();
assert_eq!(job.tool(), DbTool::Psql);
}
}
-558
Переглянути файл
@@ -1,558 +0,0 @@
//! Client tools of a database (`pg_dump`, `pg_restore`, `psql`): finding installed copies, the
//! arguments and environment that connect them like the data source, and running them.
mod jobs;
pub use jobs::*;
use crate::source::{DataSource, DbDriver, DbSslMode};
use ide_core::{CancellationToken, IdeError, IdeResult};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::ffi::OsStr;
use std::path::{Path, PathBuf};
use std::process::Stdio;
use std::time::Duration;
use tokio::io::{AsyncBufReadExt, AsyncRead, BufReader};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum DbTool {
PgDump,
PgRestore,
Psql,
}
impl DbTool {
pub fn program(self) -> &'static str {
self.programs()[0]
}
/// Executable names.
pub fn programs(self) -> &'static [&'static str] {
match self {
DbTool::PgDump => &["pg_dump"],
DbTool::PgRestore => &["pg_restore"],
DbTool::Psql => &["psql"],
}
}
pub fn driver(self) -> DbDriver {
DbDriver::Postgres
}
/// Whether `path` names this tool (`pg_dump`, `pg_dump.exe`, `pg_dump-17`…).
/// The data source's password is handed only to such a program.
pub fn is_program(self, path: &Path) -> bool {
let Some(stem) = path.file_stem().and_then(OsStr::to_str) else { return false };
self.programs().iter().any(|p| {
stem.strip_prefix(p).is_some_and(|rest| {
let digits = rest.strip_prefix(['-', '.', '_']).unwrap_or(rest);
digits.chars().all(|c| c.is_ascii_digit())
})
})
}
}
/// An installed copy of a tool.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", rename = "DbToolInstall")]
pub struct ToolInstall {
pub path: String,
/// First line of `--version`, e.g. `pg_dump (PostgreSQL) 17.2`.
pub version: String,
}
/// A line the tool wrote.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase", rename = "DbToolLine")]
pub struct ToolLine {
pub stderr: bool,
pub text: String,
}
/// Directories holding the tools that are often missing from `PATH`, by platform.
fn known_dirs() -> Vec<PathBuf> {
let mut dirs = Vec::new();
if cfg!(target_os = "macos") {
for prefix in ["/opt/homebrew", "/usr/local"] {
dirs.push(PathBuf::from(format!("{prefix}/bin")));
let opt = PathBuf::from(format!("{prefix}/opt"));
for keg in ["libpq", "postgresql"] {
dirs.extend(children(&opt, keg).into_iter().map(|d| d.join("bin")));
}
}
dirs.extend(
children(Path::new("/Applications/Postgres.app/Contents/Versions"), "").into_iter().map(|d| d.join("bin")),
);
} else if cfg!(windows) {
for var in ["ProgramFiles", "ProgramFiles(x86)"] {
if let Some(base) = std::env::var_os(var) {
let root = PathBuf::from(base).join("PostgreSQL");
dirs.extend(children(&root, "").into_iter().map(|d| d.join("bin")));
}
}
} else {
dirs.extend(children(Path::new("/usr/lib/postgresql"), "").into_iter().map(|d| d.join("bin")));
dirs.extend(children(Path::new("/usr"), "pgsql-").into_iter().map(|d| d.join("bin")));
}
dirs
}
/// Subdirectories of `parent` whose name starts with `prefix`, newest version first.
fn children(parent: &Path, prefix: &str) -> Vec<PathBuf> {
let Ok(entries) = std::fs::read_dir(parent) else { return Vec::new() };
let mut dirs: Vec<PathBuf> = entries
.flatten()
.filter(|e| e.file_name().to_str().is_some_and(|n| n.starts_with(prefix)))
.map(|e| e.path())
.filter(|p| p.is_dir())
.collect();
dirs.sort_by_key(|p| std::cmp::Reverse(version_key(&p.to_string_lossy())));
dirs
}
/// The numbers in `text`, for comparing versions (`17.2` after `9.6`).
fn version_key(text: &str) -> Vec<u32> {
text.split(|c: char| !c.is_ascii_digit()).filter_map(|n| n.parse().ok()).collect()
}
/// The installed copies of `tool` on `PATH` and in the usual install directories, newest first.
/// Blocking: runs each one's `--version`.
pub fn find_installs(tool: DbTool) -> Vec<ToolInstall> {
let path = ide_core::process::host_var_os("PATH").unwrap_or_default();
let mut dirs: Vec<PathBuf> = std::env::split_paths(&path).collect();
dirs.extend(known_dirs());
let mut seen = Vec::new();
let mut out = Vec::new();
for dir in dirs {
for program in tool.programs() {
let Some(found) = ide_core::process::find_executable(program, dir.as_os_str()) else { continue };
let real = dunce::canonicalize(&found).unwrap_or_else(|_| found.clone());
if seen.contains(&real) {
continue;
}
seen.push(real);
if let Ok(version) = version_of(&found) {
out.push(ToolInstall { path: found.to_string_lossy().into_owned(), version });
}
}
}
out.sort_by_key(|i| std::cmp::Reverse(version_key(&i.version)));
out
}
/// The first line `path --version` prints. Blocking.
pub fn version_of(path: &Path) -> IdeResult<String> {
let (ok, text) = capture(path, "--version")?;
match text.lines().next().map(str::trim).filter(|l| !l.is_empty()) {
Some(line) if ok => Ok(line.to_owned()),
_ => Err(IdeError::invalid(format!("{} is not a working executable", path.display()))),
}
}
/// Runs `path arg` for at most five seconds; whether it succeeded, and its standard output.
fn capture(path: &Path, arg: &str) -> IdeResult<(bool, String)> {
if !path.is_file() {
return Err(IdeError::not_found(format!("{} does not exist", path.display())));
}
let mut cmd = std::process::Command::new(path);
cmd.arg(arg).stdin(Stdio::null()).stdout(Stdio::piped()).stderr(Stdio::null());
ide_core::process::prepare(&mut cmd);
let mut child = cmd.spawn().map_err(|e| IdeError::invalid(format!("cannot run {}: {e}", path.display())))?;
let mut stdout = child.stdout.take().expect("piped");
let reader = std::thread::spawn(move || {
let mut buf = Vec::new();
let _ = std::io::Read::read_to_end(&mut stdout, &mut buf);
buf
});
let deadline = std::time::Instant::now() + Duration::from_secs(5);
let status = loop {
if let Some(status) = child.try_wait()? {
break status;
}
if std::time::Instant::now() > deadline {
let _ = child.kill();
let _ = child.wait();
return Err(IdeError::invalid(format!("{} {arg} did not finish", path.display())));
}
std::thread::sleep(Duration::from_millis(20));
};
let out = reader.join().unwrap_or_default();
Ok((status.success(), String::from_utf8_lossy(&out).into_owned()))
}
/// What made a dump, read from its first bytes (a directory: its `toc.dat`).
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum DbDumpKind {
/// `pg_dump` custom or tar archive, or a directory archive: `pg_restore`.
PostgresArchive,
/// Plain SQL from `pg_dump`: `psql`.
PostgresSql,
/// `mysqldump` / `mariadb-dump`: not for the PostgreSQL tools.
MysqlSql,
Unknown,
}
/// Blocking: reads at most the first 4 KiB.
pub fn dump_kind(path: &Path) -> IdeResult<DbDumpKind> {
use std::io::Read;
if path.is_dir() {
return Ok(if path.join("toc.dat").is_file() { DbDumpKind::PostgresArchive } else { DbDumpKind::Unknown });
}
let mut head = Vec::with_capacity(4096);
std::fs::File::open(path)
.map_err(|e| IdeError::not_found(format!("cannot read {}: {e}", path.display())))?
.take(4096)
.read_to_end(&mut head)?;
Ok(kind_of(&head))
}
fn kind_of(head: &[u8]) -> DbDumpKind {
// A tar archive keeps `toc.dat` first; its name starts the 512-byte header.
if head.starts_with(b"PGDMP") || head.starts_with(b"toc.dat\0") {
return DbDumpKind::PostgresArchive;
}
let text = String::from_utf8_lossy(head);
let comments: Vec<&str> = text.lines().take(20).filter(|l| l.starts_with("--")).collect();
if comments.iter().any(|l| l.contains("PostgreSQL database dump")) {
DbDumpKind::PostgresSql
} else if comments.iter().any(|l| l.starts_with("-- MySQL dump") || l.starts_with("-- MariaDB dump")) {
DbDumpKind::MysqlSql
} else {
DbDumpKind::Unknown
}
}
/// Arguments and environment that connect `tool` to `source` (already resolved, through its
/// tunnel when it has one). The password is left to [`prepare`].
pub fn connection(tool: DbTool, source: &DataSource) -> (Vec<String>, Vec<(String, String)>) {
let mut args = Vec::new();
let host = source.host.trim();
if !host.is_empty() {
args.push(format!("--host={host}"));
}
args.push(format!("--port={}", source.port.or(source.driver.default_port()).unwrap_or(5432)));
if !source.user.trim().is_empty() {
args.push(format!("--username={}", source.user.trim()));
}
if !source.database.is_empty() {
args.push(format!("--dbname={}", dbname_arg(&source.database)));
}
// Without a terminal a password prompt would wait forever: fail instead.
args.push("--no-password".into());
let mut env = vec![
("PGAPPNAME".to_owned(), format!("OpenIDEA {}", tool.program())),
(
"PGSSLMODE".to_owned(),
match source.ssl {
DbSslMode::Disable => "disable",
DbSslMode::Prefer => "prefer",
DbSslMode::Require => "require",
DbSslMode::VerifyCa => "verify-ca",
DbSslMode::VerifyFull => "verify-full",
}
.to_owned(),
),
];
for (var, file) in [
("PGSSLROOTCERT", &source.ssl_ca_file),
("PGSSLCERT", &source.ssl_cert_file),
("PGSSLKEY", &source.ssl_key_file),
] {
if !file.trim().is_empty() {
env.push((var.to_owned(), ide_ssh::expand(file.trim()).to_string_lossy().into_owned()));
}
}
if source.read_only {
env.push(("PGOPTIONS".to_owned(), "-c default_transaction_read_only=on".to_owned()));
}
(args, env)
}
/// `--dbname` reads a connection string or URI as connection parameters: such a database name
/// goes in quoted as the string's `dbname`, so it cannot pick another host or credentials.
fn dbname_arg(name: &str) -> String {
if name.contains('=') || name.starts_with("postgresql://") || name.starts_with("postgres://") {
format!("dbname='{}'", name.replace('\\', "\\\\").replace('\'', "\\'"))
} else {
name.to_owned()
}
}
/// How a tool is started: connection arguments, then the job's, and the environment.
pub struct Prepared {
pub args: Vec<String>,
pub env: Vec<(String, String)>,
}
/// The command for `job` against `source`. The password goes in `PGPASSWORD`, never in the
/// arguments, which other users of the machine can read in the process list.
pub fn prepare(job: &DbToolJob, source: &DataSource, password: Option<&str>) -> Prepared {
let (mut args, mut env) = connection(job.tool(), source);
args.extend(job.args());
if let Some(p) = password.filter(|p| !p.is_empty()) {
env.push(("PGPASSWORD".into(), p.to_owned()));
}
Prepared { args, env }
}
/// Runs `program` until it exits, passing its output in batches. Returns the exit code
/// (`None`: ended by a signal). Cancelling kills it and everything it started.
pub async fn run(
program: &Path,
args: &[String],
env: &[(String, String)],
cancel: &CancellationToken,
mut on_output: impl FnMut(Vec<ToolLine>),
) -> IdeResult<Option<i32>> {
let mut cmd = tokio::process::Command::new(program);
cmd.args(args)
.envs(env.iter().map(|(k, v)| (k, v)))
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.kill_on_drop(true);
ide_core::process::prepare(cmd.as_std_mut());
ide_core::process::own_group(cmd.as_std_mut());
let mut child = cmd.spawn().map_err(|e| IdeError::invalid(format!("cannot start {}: {e}", program.display())))?;
let (tx, mut rx) = tokio::sync::mpsc::unbounded_channel();
if let Some(out) = child.stdout.take() {
forward(out, false, tx.clone());
}
if let Some(err) = child.stderr.take() {
forward(err, true, tx);
}
let mut batch = Vec::new();
let mut tick = tokio::time::interval(Duration::from_millis(100));
loop {
tokio::select! {
line = rx.recv() => match line {
Some(line) => {
batch.push(line);
if batch.len() >= 500 {
on_output(std::mem::take(&mut batch));
}
}
None => break,
},
_ = tick.tick() => {
if !batch.is_empty() {
on_output(std::mem::take(&mut batch));
}
}
_ = cancel.cancelled() => {
if let Some(pid) = child.id() {
ide_core::process::kill_tree_of(pid);
}
let _ = child.kill().await;
return Err(IdeError::cancelled());
}
}
}
if !batch.is_empty() {
on_output(batch);
}
let status = tokio::select! {
status = child.wait() => status?,
_ = cancel.cancelled() => {
if let Some(pid) = child.id() {
ide_core::process::kill_tree_of(pid);
}
let _ = child.kill().await;
return Err(IdeError::cancelled());
}
};
Ok(status.code())
}
fn forward(
pipe: impl AsyncRead + Unpin + Send + 'static,
stderr: bool,
tx: tokio::sync::mpsc::UnboundedSender<ToolLine>,
) {
tokio::spawn(async move {
let mut reader = BufReader::new(pipe);
let mut buf = Vec::new();
loop {
buf.clear();
match reader.read_until(b'\n', &mut buf).await {
Ok(0) | Err(_) => break,
Ok(_) => {
let text = String::from_utf8_lossy(&buf).trim_end_matches(['\r', '\n']).to_owned();
if tx.send(ToolLine { stderr, text }).is_err() {
break;
}
}
}
}
});
}
#[cfg(test)]
mod tests {
use super::*;
fn pg() -> DataSource {
DataSource {
driver: DbDriver::Postgres,
host: "db.example.test".into(),
port: Some(6543),
user: "app".into(),
database: "shop".into(),
..DataSource::default()
}
}
#[test]
fn connects_like_the_data_source_without_prompting() {
let (args, env) = connection(DbTool::PgDump, &pg());
assert_eq!(args, ["--host=db.example.test", "--port=6543", "--username=app", "--dbname=shop", "--no-password"]);
assert!(env.contains(&("PGSSLMODE".into(), "prefer".into())));
assert!(!env.iter().any(|(k, _)| k == "PGPASSWORD" || k == "PGOPTIONS"));
}
#[test]
fn a_database_named_like_connection_parameters_stays_a_name() {
for (name, arg) in [
("host=evil.example dbname=p", r"--dbname=dbname='host=evil.example dbname=p'"),
(r"it's=\x", r"--dbname=dbname='it\'s=\\x'"),
("postgresql://evil.example/p", "--dbname=dbname='postgresql://evil.example/p'"),
] {
let (args, _) = connection(DbTool::PgDump, &DataSource { database: name.into(), ..pg() });
assert!(args.contains(&arg.to_owned()), "{args:?}");
}
}
#[test]
fn default_port_and_optional_fields() {
let source = DataSource { port: None, user: String::new(), database: String::new(), ..pg() };
let (args, _) = connection(DbTool::Psql, &source);
assert_eq!(args, ["--host=db.example.test", "--port=5432", "--no-password"]);
}
#[test]
fn read_only_sources_refuse_writes() {
let source = DataSource { read_only: true, ssl: DbSslMode::VerifyFull, ..pg() };
let (_, env) = connection(DbTool::PgRestore, &source);
assert!(env.contains(&("PGOPTIONS".into(), "-c default_transaction_read_only=on".into())));
assert!(env.contains(&("PGSSLMODE".into(), "verify-full".into())));
}
#[test]
fn only_the_tool_itself_is_accepted() {
for ok in ["/usr/bin/pg_dump", "/pg/bin/pg_dump.exe", "/usr/bin/pg_dump-17", "/opt/pg_dump17"] {
assert!(DbTool::PgDump.is_program(Path::new(ok)), "{ok}");
}
for bad in ["/usr/bin/pg_dumpall", "/bin/sh", "/usr/bin/pg_restore", "/tmp/evil"] {
assert!(!DbTool::PgDump.is_program(Path::new(bad)), "{bad}");
}
}
#[test]
fn tells_dumps_apart_by_their_header() {
assert_eq!(kind_of(b"PGDMP\x01\x0f"), DbDumpKind::PostgresArchive);
assert_eq!(kind_of(b"toc.dat\0\0\0"), DbDumpKind::PostgresArchive);
assert_eq!(kind_of(b"--\n-- PostgreSQL database dump\n--\n"), DbDumpKind::PostgresSql);
assert_eq!(kind_of(b"-- MySQL dump 10.13 Distrib 8.4.6\n--\n"), DbDumpKind::MysqlSql);
assert_eq!(kind_of(b"-- MariaDB dump 10.19 Distrib 11.4.2\n"), DbDumpKind::MysqlSql);
assert_eq!(kind_of(b"CREATE TABLE t (id int);\n"), DbDumpKind::Unknown);
}
#[test]
fn newer_versions_sort_first() {
assert!(version_key("pg_dump (PostgreSQL) 17.2") > version_key("pg_dump (PostgreSQL) 9.6.24"));
}
#[cfg(unix)]
#[tokio::test]
async fn streams_both_pipes_and_reports_the_exit_code() {
let mut lines = Vec::new();
let code = run(
Path::new("/bin/sh"),
&["-c".into(), "echo out; echo err >&2; exit 3".into()],
&[],
&CancellationToken::new(),
|batch| lines.extend(batch),
)
.await
.unwrap();
assert_eq!(code, Some(3));
assert!(lines.contains(&ToolLine { stderr: false, text: "out".into() }));
assert!(lines.contains(&ToolLine { stderr: true, text: "err".into() }));
}
#[cfg(unix)]
#[tokio::test]
async fn cancelling_stops_the_process() {
let cancel = CancellationToken::new();
let stop = cancel.clone();
tokio::spawn(async move {
tokio::time::sleep(Duration::from_millis(100)).await;
stop.cancel();
});
let result = run(Path::new("/bin/sh"), &["-c".into(), "sleep 30".into()], &[], &cancel, |_| {}).await;
assert!(result.is_err());
}
/// A stand-in for `tool` that prints each argument on a line, then whether `PGPASSWORD`
/// holds the expected password.
#[cfg(unix)]
fn echo_tool(dir: &Path, tool: DbTool) -> PathBuf {
use std::os::unix::fs::PermissionsExt;
let path = dir.join(tool.program());
std::fs::write(
&path,
"#!/bin/sh\nfor a in \"$@\"; do echo \"arg:$a\"; done\necho \"env:${PGPASSWORD:+set}\"\n",
)
.unwrap();
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o755)).unwrap();
path
}
#[cfg(unix)]
#[tokio::test]
async fn the_password_never_reaches_the_arguments() {
const SECRET: &str = "s3cret-pass-do-not-leak";
let dir = std::env::temp_dir().join(format!("openidea-tools-{}", uuid::Uuid::new_v4()));
std::fs::create_dir_all(&dir).unwrap();
let file = dir.join("out.sql").to_string_lossy().into_owned();
let jobs = [
DbToolJob::PgDump {
file: file.clone(),
options: DbPgDumpOptions {
format: DbDumpFormat::Plain,
statements: DbDumpStatements::Copy,
content: DbDumpContent::All,
schemas: vec!["public".into()],
tables: vec![],
exclude_tables: vec![],
clean: true,
if_exists: true,
create: false,
no_owner: false,
no_privileges: false,
jobs: 1,
},
},
DbToolJob::Psql {
file: file.clone(),
options: DbPsqlOptions { single_transaction: true, stop_on_error: true },
},
];
for job in jobs {
let program = echo_tool(&dir, job.tool());
let prepared = prepare(&job, &pg(), Some(SECRET));
assert!(!prepared.args.iter().any(|a| a.contains(SECRET)), "{:?}", prepared.args);
let mut lines = Vec::new();
run(&program, &prepared.args, &prepared.env, &CancellationToken::new(), |b| lines.extend(b)).await.unwrap();
let text: Vec<&str> = lines.iter().map(|l| l.text.as_str()).collect();
assert!(text.contains(&"arg:--dbname=shop"), "{text:?}");
assert!(!text.iter().any(|l| l.contains(SECRET)), "{text:?}");
assert!(text.contains(&"env:set"), "the tool gets the password from PGPASSWORD: {text:?}");
}
std::fs::remove_dir_all(&dir).unwrap();
}
}
-75
Переглянути файл
@@ -228,78 +228,3 @@ async fn opening_a_table_reads_multi_column_keys_in_order() -> IdeResult<()> {
db.execute("p", "DROP SCHEMA oi_keys CASCADE", 10, &c).await?;
Ok(())
}
/// Runs `job` with the newest installed copy of its tool, the way the dialogs do.
async fn run_tool(db: &DbManager, target: &str, job: ide_db::tools::DbToolJob) -> IdeResult<()> {
let install = ide_db::tools::find_installs(job.tool()).into_iter().next().expect("installed");
let mut lines = Vec::new();
let code = db.run_tool(target, install.path.as_ref(), &job, &CancellationToken::new(), |b| lines.extend(b)).await?;
assert_eq!(code, Some(0), "{} failed: {lines:?}", job.tool().program());
Ok(())
}
#[tokio::test]
async fn dumps_and_restores_with_the_client_tools() -> IdeResult<()> {
use ide_db::tools::{
DbDumpContent, DbDumpFormat, DbDumpStatements, DbPgDumpOptions, DbPgRestoreOptions, DbPsqlOptions, DbTool,
DbToolJob, find_installs,
};
let tmp = tempfile::tempdir().unwrap();
let Some(db) = manager(&tmp).await else { return Ok(()) };
let server = db.server_version("p").await? / 10000;
let major = |t: DbTool| {
find_installs(t).first().and_then(|i| i.version.split(' ').nth(2)?.split('.').next()?.parse::<u32>().ok())
};
// Other major versions write or refuse what this server needs; the dialogs warn about that instead.
if [DbTool::PgDump, DbTool::PgRestore, DbTool::Psql].into_iter().any(|t| major(t) != Some(server)) {
return Ok(());
}
create_schemas(&db).await;
let c = CancellationToken::new();
db.execute("p", "DROP DATABASE IF EXISTS oi_restore", 1, &c).await?;
db.execute("p", "CREATE DATABASE oi_restore", 1, &c).await?;
let file = |name: &str| tmp.path().join(name).to_string_lossy().into_owned();
let dump = |format, file: String, schema: &str| DbToolJob::PgDump {
file,
options: DbPgDumpOptions {
format,
statements: DbDumpStatements::Copy,
content: DbDumpContent::All,
schemas: vec![schema.into()],
tables: vec![],
exclude_tables: vec![],
clean: false,
if_exists: false,
create: false,
no_owner: false,
no_privileges: false,
jobs: 1,
},
};
let archive = file("a.dump");
run_tool(&db, "p", dump(DbDumpFormat::Custom, archive.clone(), "oi_a")).await?;
let restore = DbPgRestoreOptions {
content: DbDumpContent::All,
schemas: vec![],
clean: false,
if_exists: false,
no_owner: false,
no_privileges: false,
single_transaction: false,
exit_on_error: true,
jobs: 1,
};
run_tool(&db, "p:oi_restore", DbToolJob::PgRestore { file: archive, options: restore }).await?;
let script = file("b.sql");
run_tool(&db, "p", dump(DbDumpFormat::Plain, script.clone(), "oi_b")).await?;
let psql = DbPsqlOptions { single_transaction: true, stop_on_error: true };
run_tool(&db, "p:oi_restore", DbToolJob::Psql { file: script, options: psql }).await?;
let r = db.execute("p:oi_restore", "SELECT a.tag || ', ' || b.tag FROM oi_a.items a, oi_b.items b", 1, &c).await?;
assert_eq!(r.rows[0][0].as_deref(), Some("from a, from b"));
db.disconnect("p:oi_restore").await;
db.execute("p", "DROP DATABASE oi_restore", 1, &c).await?;
Ok(())
}
+2 -21
Переглянути файл
@@ -26,8 +26,6 @@ pub enum Capability {
DatabaseSources,
VcsRead,
VcsWrite,
/// The Maven / Gradle dependency graph the IDE resolved.
BuildRead,
/// The plugin's own key-value store and data directory.
Storage,
/// The plugin's own secrets (kept in the client's OS keychain).
@@ -57,9 +55,6 @@ pub enum Capability {
FsRead(String),
/// Write files outside the project under one path.
FsWrite(String),
/// Load the plugin's Java agent into the JVMs of Java run configurations. Never
/// declared: it comes from `[[contributes.javaAgents]]`.
JavaAgent,
}
/// How a grant is presented (plan 4.2).
@@ -77,9 +72,7 @@ pub enum Risk {
impl Capability {
pub fn risk(&self) -> Risk {
match self {
Self::ProjectRead | Self::EditorRead | Self::Storage | Self::Events | Self::VcsRead | Self::BuildRead => {
Risk::Low
}
Self::ProjectRead | Self::EditorRead | Self::Storage | Self::Events | Self::VcsRead => Risk::Low,
Self::EditorWrite
| Self::DatabaseSources
| Self::VcsWrite
@@ -97,8 +90,7 @@ impl Capability {
| Self::Process(_)
| Self::Lsp(_)
| Self::FsRead(_)
| Self::FsWrite(_)
| Self::JavaAgent => Risk::High,
| Self::FsWrite(_) => Risk::High,
}
}
@@ -119,7 +111,6 @@ impl Capability {
Self::IdeCommands => "Run any IDE action or other plugins' commands as if you chose them, including running programs, committing and pushing".into(),
Self::VcsRead => "Read version control state".into(),
Self::VcsWrite => "Change version control state (commit, fetch, checkout)".into(),
Self::BuildRead => "Read the project's resolved Maven and Gradle dependencies".into(),
Self::Storage => "Store its own data".into(),
Self::Secrets => "Store secrets in the system keychain".into(),
Self::Events => "Observe editor, filesystem and version control events".into(),
@@ -144,7 +135,6 @@ impl Capability {
}
Self::FsRead(path) => format!("Read files under {path}, outside the project"),
Self::FsWrite(path) => format!("Change files under {path}, outside the project"),
Self::JavaAgent => "Run code inside the Java applications you start".into(),
}
}
@@ -256,7 +246,6 @@ impl fmt::Display for Capability {
Self::DatabaseSources => f.write_str("database.sources"),
Self::VcsRead => f.write_str("vcs.read"),
Self::VcsWrite => f.write_str("vcs.write"),
Self::BuildRead => f.write_str("build.read"),
Self::Storage => f.write_str("storage"),
Self::Secrets => f.write_str("secrets"),
Self::Events => f.write_str("events"),
@@ -270,7 +259,6 @@ impl fmt::Display for Capability {
Self::Lsp(s) => write!(f, "lsp:{s}"),
Self::FsRead(p) => write!(f, "fs.read:{p}"),
Self::FsWrite(p) => write!(f, "fs.write:{p}"),
Self::JavaAgent => f.write_str("java.agent"),
}
}
}
@@ -342,13 +330,11 @@ impl FromStr for Capability {
"database.sources" => Self::DatabaseSources,
"vcs.read" => Self::VcsRead,
"vcs.write" => Self::VcsWrite,
"build.read" => Self::BuildRead,
"storage" => Self::Storage,
"secrets" => Self::Secrets,
"events" => Self::Events,
"events.input" => Self::InputEvents,
"clipboard" => Self::Clipboard,
"java.agent" => Self::JavaAgent,
_ => return Err(format!("unknown capability {s:?}")),
})
}
@@ -397,7 +383,6 @@ mod tests {
"editor.write",
"project.write",
"vcs.write",
"build.read",
"storage",
"secrets",
"events",
@@ -407,7 +392,6 @@ mod tests {
"process:cargo",
"lsp:phoxite",
"lsp:rust-analyzer",
"java.agent",
] {
assert_eq!(s.parse::<Capability>().unwrap().to_string(), s);
}
@@ -441,11 +425,8 @@ mod tests {
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_eq!(Capability::BuildRead.risk(), Risk::Low);
assert!(!Capability::Lsp("phoxite".into()).covers(&Capability::Lsp("intelephense".into())));
assert!(Capability::Storage.auto_migrates() && !Capability::EditorWrite.auto_migrates());
assert_eq!(Capability::JavaAgent.risk(), Risk::High);
assert!(!Capability::JavaAgent.auto_migrates());
}
/// A trusted project's files name programs the IDE starts by itself: the git and language
+2 -19
Переглянути файл
@@ -10,8 +10,6 @@
//! - `process:<program>` grants record the program's absolute path and file
//! hash at grant time. Calls use that path, never a `PATH` lookup, and fail
//! when the file changed (re-confirmation needed).
//! - `java.agent` grants record the agent jar's path and hash the same way;
//! a launch adds the agent only while the jar still has that hash.
use crate::capability::{Capability, Risk};
use serde::{Deserialize, Serialize};
@@ -269,7 +267,7 @@ impl Ledger {
if cap == &Capability::NetAsk {
grant.net_hosts.clear();
}
if let Capability::Process(_) | Capability::JavaAgent = cap {
if let Capability::Process(_) = cap {
grant.binaries.remove(&s);
for binaries in grant.project_binaries.values_mut() {
binaries.remove(&s);
@@ -292,7 +290,7 @@ impl Ledger {
self.grants.get_mut(subject).is_some_and(|g| g.net_hosts.remove(host))
}
/// Records the program approved for a `process:` grant (or the jar of a `java.agent` one).
/// Records the program approved for a `process:` grant.
pub fn set_binary(&mut self, subject: &Subject, cap: &Capability, binary: BinaryGrant) {
if let Some(grant) = self.grants.get_mut(subject) {
grant.binaries.insert(cap.to_string(), binary);
@@ -677,21 +675,6 @@ mod tests {
assert!(l.check_binary(&r.subject, &cap).unwrap_err().contains("changed"));
}
#[test]
fn revoking_java_agent_forgets_its_jar() {
let mut l = Ledger::in_memory();
let r = req("1.0.0", "h", &[], &["java.agent"]);
let cap = Capability::JavaAgent;
let jar = BinaryGrant { path: "/plugins/p/agent.jar".into(), hash: "abc".into() };
l.confirm(&r, std::slice::from_ref(&cap), [(cap.to_string(), jar.clone())].into());
assert_eq!(l.pinned_binary(&r.subject, &cap), Some(jar.clone()));
l.set(&r.subject, &cap, false);
assert_eq!(l.pinned_binary(&r.subject, &cap), None);
// Granting again without a new hash does not bring the old one back.
l.set(&r.subject, &cap, true);
assert_eq!(l.pinned_binary(&r.subject, &cap), None);
}
#[test]
fn hashes_and_grouping() {
let tmp = tempfile::tempdir().unwrap();
+1 -25
Переглянути файл
@@ -34,7 +34,7 @@ use std::path::{Component, Path, PathBuf};
pub const MANIFEST_FILE: &str = "plugin.toml";
/// The plugin API (engine) version this host implements.
pub const ENGINE_VERSION: &str = "1.10.0";
pub const ENGINE_VERSION: &str = "1.9.0";
/// The 0.1 API, still accepted for contribution-only packages and 0.1 components.
pub const LEGACY_API: &str = "0.1";
/// Marketplace categories, in the order they are shown.
@@ -360,14 +360,6 @@ impl Manifest {
if matches!(cap, Capability::Lsp(_)) {
self.needs_api(&format!("capability `{cap}`"), 9)?;
}
if matches!(cap, Capability::BuildRead) {
self.needs_api(&format!("capability `{cap}`"), 10)?;
}
if matches!(cap, Capability::JavaAgent) {
return Err(
"`java.agent` comes from `[[contributes.javaAgents]]`: remove it from [capabilities]".into()
);
}
}
if let Some(dark) = &self.icon_dark {
if self.icon.is_none() {
@@ -738,22 +730,6 @@ required = [\"lsp:phoxite\"]
assert_eq!(m.capabilities.required, [Capability::Lsp("phoxite".into())]);
}
#[test]
fn the_build_capability_needs_api_1_10() {
let caps = "[capabilities]\noptional = [\"build.read\"]\n";
assert!(err(&format!("{}{caps}", BASE.replace("^1.2", "^1.9"))).contains("new in plugin API 1.10"));
let m = Manifest::parse(&format!("{}{caps}", BASE.replace("^1.2", "^1.10"))).unwrap();
assert_eq!(m.capabilities.optional, [Capability::BuildRead]);
}
#[test]
fn java_agent_capability_is_not_declared() {
for list in ["required", "optional"] {
let caps = format!("[capabilities]\n{list} = [\"java.agent\"]\n");
assert!(err(&format!("{}{caps}", BASE.replace("^1.2", "^1.10"))).contains("contributes.javaAgents"));
}
}
#[test]
fn parses_icons() {
let m = Manifest::parse(&format!("{BASE}icon = \"icon.svg\"\nicon-dark = \"icon_dark.svg\"\n")).unwrap();
-2
Переглянути файл
@@ -30,8 +30,6 @@ ide-vcs.workspace = true
ide-dap.workspace = true
ide-heap.workspace = true
ide-jvm-attach.workspace = true
ide-jvm-inspect.workspace = true
ide-streams.workspace = true
ide-build.workspace = true
ide-analysis.workspace = true
ide-coverage.workspace = true
-6
Переглянути файл
@@ -191,12 +191,6 @@ impl Host {
};
host.apply_proxy();
host.apply_added_jdks();
// Before any project starts jdtls; the deleting itself can take a while.
let unused =
ide_sdk::jdtls_workspaces::take_unused(&host.local_data_dir, ide_sdk::jdtls_workspaces::UNUSED_FOR);
if !unused.is_empty() {
std::thread::spawn(move || ide_sdk::jdtls_workspaces::remove(unused));
}
ops::agent::move_user_mcp_values(&host);
host
}
+2 -7
Переглянути файл
@@ -25,17 +25,12 @@ impl Scope {
} else {
call.root().join(given)
});
let roots: Vec<PathBuf> =
std::iter::once(call.root().to_path_buf()).chain(call.project().content_roots()).collect();
// Before touching the file system: on Windows, resolving `\\host\share` signs in to that host.
if !ide_vfs::content_path_allowed(&path, &roots) {
return Err(IdeError::invalid(format!("scope {raw} is outside the project")));
}
let path = dunce::canonicalize(&path).unwrap_or(path);
if !path.is_dir() {
return Err(IdeError::not_found(format!("scope {raw} is not a directory")));
}
if !roots.iter().any(|root| path.starts_with(root)) {
let roots = std::iter::once(call.root().to_path_buf()).chain(call.project().content_roots());
if !roots.into_iter().any(|root| path.starts_with(root)) {
return Err(IdeError::invalid(format!("scope {raw} is outside the project")));
}
Ok(Self(Some(path)))
+9 -19
Переглянути файл
@@ -883,20 +883,14 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
let host = call.host();
let project = call.project().clone();
let indexing_before = project.index.status().indexing;
let pool = if scope.is_all() { limit + 1 } else { ((limit + 1) * SYMBOL_POOL_FACTOR).min(MAX_SYMBOL_POOL) };
let pool = if scope.is_all() && dir.dir().is_none() {
limit + 1
} else {
((limit + 1) * SYMBOL_POOL_FACTOR).min(MAX_SYMBOL_POOL)
};
let found = {
let (project, q, dir) = (project.clone(), q.clone(), dir.dir().map(Path::to_path_buf));
host.blocking(move || {
Ok(match dir {
// Filtered in the index: a pool cut before the filter could miss every match.
Some(dir) => project
.index
.find_symbols_until(&q, ide_index::SymbolFilter::All, pool, &|p| p.starts_with(&dir), &|| false)
.unwrap_or_default(),
None => project.index.find_symbols(&q, ide_index::SymbolFilter::All, pool),
})
})
.await?
let (project, q) = (project.clone(), q.clone());
host.blocking(move || Ok(project.index.find_symbols(&q, ide_index::SymbolFilter::All, pool))).await?
};
let mut items: Vec<SearchItem> = found
.into_iter()
@@ -916,14 +910,10 @@ async fn symbol_search(call: Call) -> IdeResult<Output> {
let budget = MEDIUM_TIMEOUT.saturating_sub(started.elapsed());
let (symbols, out_of_time) = workspace_symbols(&call, &q, budget).await;
timed_out = out_of_time;
let mut roots = project.content_roots();
roots.extend(crate::mcp::tool::attached_projects(call.root()));
for (name, container, location) in symbols {
let path = location.uri.clone().unwrap_or_else(|| call.display(&location.path));
// Project files (attached projects' too) obey `scope` and `paths`; library symbols
// are what was asked for.
let inside = location.uri.is_none()
&& (!Path::new(&path).is_absolute() || roots.iter().any(|r| location.path.starts_with(r)));
// Project files obey `scope` and `paths`; library symbols are what was asked for.
let inside = location.uri.is_none() && !Path::new(&path).is_absolute();
if inside && !(dir.contains_shown(call.root(), &path) && scope.matches(&path)) {
continue;
}
+3 -9
Переглянути файл
@@ -30,15 +30,9 @@ pub fn providers(host: &Host, window: &str) -> IdeResult<Vec<AgentProvider>> {
}
/// Refreshes the selected agent's model catalog without sending a prompt.
pub fn refresh_models(
host: &Host,
window: &str,
provider: String,
force: bool,
model: Option<String>,
) -> IdeResult<AgentModelCatalog> {
pub fn refresh_models(host: &Host, window: &str, provider: String, force: bool) -> IdeResult<AgentModelCatalog> {
host.require_trust(window)?;
host.project(window)?.agents.refresh_models(&provider, force, model.as_deref())
host.project(window)?.agents.refresh_models(&provider, force)
}
/// Overrides built-in agent `id`'s command with `command` (its agent file keeps the
@@ -838,7 +832,7 @@ pub(crate) fn register(d: &mut Dispatcher) {
d.add("agent_subscribe", |c| async move { subscribe(&c.host, &c.window, c.channel("onEvent")?) });
d.add("agent_providers", |c| async move { providers(&c.host, &c.window) });
d.add("agent_refresh_models", |c| async move {
refresh_models(&c.host, &c.window, c.arg("provider")?, c.arg("force")?, c.arg("model")?)
refresh_models(&c.host, &c.window, c.arg("provider")?, c.arg("force")?)
});
d.add("agent_set_command", |c| async move { set_command(&c.host, &c.window, c.arg("id")?, c.arg("command")?) });
d.add("agent_set_env", |c| async move { set_env(&c.host, &c.window, c.arg("id")?, c.arg("env")?) });
+7 -48
Переглянути файл
@@ -311,11 +311,12 @@ pub async fn build_sync(
if completion_token.is_cancelled() {
return Err(IdeError::cancelled());
}
// Gradle may report project folders outside the project (`includeFlat`), and a Maven
// reactor may have gained or dropped modules beside it: index and list them.
project.refresh_index_scope();
let p = project.clone();
tokio::task::spawn_blocking(move || p.refresh_repositories());
if tool == BuildTool::Gradle {
// The sync may report project folders outside the project (`includeFlat`): index and list them.
project.refresh_index_scope();
let p = project.clone();
tokio::task::spawn_blocking(move || p.refresh_repositories());
}
// New source folders and dependency versions: the Project view and External Libraries reload.
project.sink.emit(ide_core::IdeEvent::ProjectRootsChanged { root: project.root.clone().into() });
if tool == BuildTool::Maven
@@ -467,15 +468,7 @@ pub async fn gradle_dependencies(
gradle_command: Some(gradle.command.clone()),
..Default::default()
};
let dependencies =
ide_build::gradle_dependencies(&scope.root, gradle, &options, &gradle_path, &configuration, &token)?;
// What plugins read of the build (`build.dependencies`) instead of running Gradle.
let report = ide_build::GradleReport { project: gradle_path, configuration, dependencies };
let cache = ide_build::gradle::cache_dir(&scope.cache, &gradle.dir);
if let Err(e) = ide_build::save_gradle_report(&scope.root, &cache, gradle, &report) {
tracing::debug!("keeping the dependencies report of {}: {e}", report.project);
}
Ok(report.dependencies)
ide_build::gradle_dependencies(&scope.root, gradle, &options, &gradle_path, &configuration, &token)
})
.await
.map_err(join_err);
@@ -483,40 +476,6 @@ pub async fn gradle_dependencies(
result?
}
/// What the Dependency Analyzer has of the builds of `project` at `root` (the project, or one
/// of its workspace members), without running a build tool: the Maven modules as last synced
/// and the Gradle reports read since the build files last changed.
pub(crate) fn analyzed_dependencies(
project: &Project,
config: &Path,
root: &Path,
) -> IdeResult<crate::plugins::BuildGraph> {
let mut graph = crate::plugins::BuildGraph::default();
for scope in workspace::scopes(project, config)?.iter().filter(|s| root == project.root || s.root == root) {
let settings = &scope.settings;
let model = ide_build::load_linked(
&scope.root,
&scope.cache,
ide_sdk::apply::maven_local_repository(&scope.root, settings),
&settings.languages.java.maven,
&settings.languages.java.gradle,
);
graph.maven.extend(model.maven.into_iter().flat_map(|m| m.projects));
for build in &model.gradle {
let reports =
ide_build::gradle_reports(&scope.root, &ide_build::gradle::cache_dir(&scope.cache, &build.dir), build);
// buildSrc can't be analyzed from the build, as in the Dependency Analyzer.
for p in build.projects.iter().filter(|p| !p.build.as_deref().is_some_and(|b| b.ends_with(":buildSrc"))) {
graph.gradle.push(crate::plugins::GradleModule {
path: p.path.clone(),
reports: reports.iter().filter(|r| r.project == p.path).cloned().collect(),
});
}
}
}
Ok(graph)
}
/// Where the direct dependency `dependency` of the Maven module `pom` is declared.
pub async fn maven_dependency_declaration(
host: &Host,
-32
Переглянути файл
@@ -532,35 +532,3 @@ fn console_dir(host: &Host, id: &str) -> IdeResult<PathBuf> {
std::fs::create_dir_all(&dir)?;
Ok(dir)
}
/// Runs a client tool against target `id` until it exits or the request is cancelled.
/// Desktop only: the file paths come from local dialogs.
pub async fn run_tool(
host: &Host,
window: &str,
request: RequestId,
id: &str,
executable: &std::path::Path,
job: &ide_db::tools::DbToolJob,
on_output: impl FnMut(Vec<ide_db::tools::ToolLine>),
) -> IdeResult<Option<i32>> {
let db = host.project(window)?.db.clone();
let cancel = host.begin_request(request);
let result = db.run_tool(id, executable, job, &cancel, on_output).await;
host.end_request(request);
result
}
pub fn tool_preview(
host: &Host,
window: &str,
id: &str,
executable: &std::path::Path,
job: &ide_db::tools::DbToolJob,
) -> IdeResult<String> {
host.project(window)?.db.tool_preview(id, executable, job)
}
pub async fn server_version(host: &Host, window: &str, id: &str) -> IdeResult<u32> {
host.project(window)?.db.server_version(id).await
}
+1 -86
Переглянути файл
@@ -31,8 +31,6 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
} else {
None
};
let agents = if is_jvm_launch(&config) { ide_run::java_agent::current() } else { Default::default() };
let config = add_java_agents(config, &agents.options);
let mut config = match_java_debug_encoding(start_java_attach_listener(config, cfg!(windows)), cfg!(windows));
if config.adapter == "debugpy"
&& config.request == "launch"
@@ -121,15 +119,6 @@ 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 let Ok(id) = &result {
let sink = host.window_sink(label);
for note in &agents.notes {
sink.emit(ide_core::IdeEvent::Debug {
session: *id,
event: ide_core::event::DebugEvent::Output { category: "console".into(), output: format!("{note}\n") },
});
}
}
if result.is_err()
&& let Some(pid) = unity_pid
{
@@ -165,54 +154,10 @@ fn debug_server_port(config: &LaunchConfig) -> Option<u16> {
fn attach_jvm_inspector(host: &Host, window: &str, session: DebugSessionId, port: u16) {
let Ok(project) = host.project(window) else { return };
let Some(module) = project.lsp.java_debug_server_module(port) else { return };
let inspector = std::sync::Arc::new(ide_lsp::JdtJvmInspector::new(project.lsp.clone(), module.clone()));
let inspector = std::sync::Arc::new(ide_lsp::JdtJvmInspector::new(project.lsp.clone(), module));
if let Err(e) = host.debugger.set_jvm_inspector(session, inspector) {
tracing::debug!("jvm inspector for session {session:?}: {e}");
return;
}
let tracer = std::sync::Arc::new(ide_lsp::JdtStreamTracer::new(project.lsp.clone(), module));
if let Err(e) = host.debugger.set_stream_tracer(session, tracer) {
tracing::debug!("stream tracer for session {session:?}: {e}");
}
}
/// A JVM the debugger starts itself: an Application or Spring Boot configuration, launched by
/// java-debug or the Kotlin debugger (JAR Application debugs through a run with a JDWP agent).
fn is_jvm_launch(config: &LaunchConfig) -> bool {
config.request == "launch" && matches!(config.adapter.as_str(), "java-debug" | ide_dap::kotlin::ADAPTER)
}
/// Plugins' Java agents ([`ide_run::java_agent`]) after the configuration's VM options:
/// java-debug's `vmArgs` (one line, or a list) or the Kotlin debugger's `vmArguments` (a list).
fn add_java_agents(mut config: LaunchConfig, options: &[String]) -> LaunchConfig {
if options.is_empty() || !is_jvm_launch(&config) {
return config;
}
let Some(serde_json::Value::Object(mut extra)) =
config.extra_json.as_deref().and_then(|e| serde_json::from_str(e).ok())
else {
return config;
};
let key = if config.adapter == "java-debug" { "vmArgs" } else { "vmArguments" };
let value = match extra.get(key) {
None | Some(serde_json::Value::Null) if key == "vmArgs" => {
ide_run::java_agent::add_to_vm_args_text("", options).into()
}
Some(serde_json::Value::String(text)) => ide_run::java_agent::add_to_vm_args_text(text, options).into(),
None | Some(serde_json::Value::Null) | Some(serde_json::Value::Array(_)) => {
let mut list: Vec<String> = extra
.get(key)
.and_then(serde_json::Value::as_array)
.map(|a| a.iter().filter_map(|v| v.as_str().map(str::to_owned)).collect())
.unwrap_or_default();
ide_run::java_agent::add_to_vm_args(&mut list, options);
list.into()
}
Some(_) => return config,
};
extra.insert(key.into(), value);
config.extra_json = Some(serde_json::Value::Object(extra).to_string());
config
}
/// The JVM memory tab reads the class table over the attach socket, which only exists once the
@@ -868,36 +813,6 @@ mod tests {
);
}
#[test]
fn plugin_java_agents_join_the_vm_options_of_jvm_launches() {
let agent = "-javaagent:/my plugins/agent.jar=port=0".to_owned();
let options = std::slice::from_ref(&agent);
let field = |config: &LaunchConfig, key: &str| {
serde_json::from_str::<serde_json::Value>(config.extra_json.as_deref().unwrap()).unwrap()[key].clone()
};
let debugged =
add_java_agents(launch("java-debug", "launch", serde_json::json!({"vmArgs": "-Xmx1g"})), options);
assert_eq!(vm_args(&debugged), "-Xmx1g \"-javaagent:/my plugins/agent.jar=port=0\"");
assert_eq!(add_java_agents(debugged.clone(), options).extra_json, debugged.extra_json, "not added twice");
let none = add_java_agents(launch("java-debug", "launch", serde_json::json!({"vmArgs": null})), options);
assert_eq!(vm_args(&none), "\"-javaagent:/my plugins/agent.jar=port=0\"");
let list = add_java_agents(launch("java-debug", "launch", serde_json::json!({"vmArgs": ["-Xmx1g"]})), options);
assert_eq!(vm_args(&list), serde_json::json!(["-Xmx1g", agent]));
let kotlin = launch(ide_dap::kotlin::ADAPTER, "launch", serde_json::json!({"vmArguments": ["-Xmx1g"]}));
assert_eq!(field(&add_java_agents(kotlin, options), "vmArguments"), serde_json::json!(["-Xmx1g", agent]));
let kotlin = launch(ide_dap::kotlin::ADAPTER, "launch", serde_json::json!({}));
assert_eq!(field(&add_java_agents(kotlin, options), "vmArguments"), serde_json::json!([agent]));
// Attaching (remote debug included), other adapters, and no granted agent: unchanged.
for config in [
launch("java-debug", "attach", serde_json::json!({"vmArgs": "-Xmx1g"})),
launch("debugpy", "launch", serde_json::json!({"vmArgs": "-Xmx1g"})),
] {
assert_eq!(add_java_agents(config.clone(), options).extra_json, config.extra_json);
}
let config = launch("java-debug", "launch", serde_json::json!({"vmArgs": "-Xmx1g"}));
assert_eq!(add_java_agents(config.clone(), &[]).extra_json, config.extra_json);
}
#[test]
fn debug_server_port_only_for_local_java_debug() {
let port = |adapter: &str, request: &str, extra| debug_server_port(&launch(adapter, request, extra));
+6 -15
Переглянути файл
@@ -5,7 +5,7 @@ use crate::rpc::Dispatcher;
use ide_core::{DocId, IdeError, IdeResult, OutlineItem, Range};
use ide_language::{FoldRange, SyntaxHighlights};
use ide_text::LineEnding;
use ide_workspace::{DocumentEncoding, DocumentInfo, DocumentLanguage, HistoryEntry};
use ide_workspace::{DocumentEncoding, DocumentInfo, HistoryEntry};
use std::path::PathBuf;
/// Runs blocking work (disk I/O, parsing, large copies) on the blocking pool,
@@ -32,17 +32,11 @@ pub async fn doc_open_virtual(host: &Host, window: &str, uri: String) -> IdeResu
.await
}
/// The language and CodeMirror mode `path` is shown with in an editor, without opening
/// it: previews of closed files and diffs. `first_line` is the shown text's (a revision's)
/// for hashbang detection; without it the file's on disk counts.
pub async fn doc_language(
host: &Host,
window: &str,
path: PathBuf,
first_line: Option<String>,
) -> IdeResult<DocumentLanguage> {
/// The CodeMirror mode `path` gets when opened (`DocumentInfo::ui_mode`),
/// without opening it: previews of closed files.
pub async fn doc_ui_mode(host: &Host, window: &str, path: PathBuf) -> IdeResult<Option<String>> {
let project = host.project(window)?;
blocking(move || Ok(project.documents.language_of(&path, first_line.as_deref()))).await
blocking(move || Ok(project.documents.ui_mode_of(&path))).await
}
/// "Reload with Encoding" (`reload`) or "Convert to Encoding"; returns the new encoding and BOM state.
@@ -215,10 +209,7 @@ pub fn history_content(host: &Host, window: &str, id: String) -> IdeResult<Strin
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("doc_open_virtual", |c| async move { doc_open_virtual(&c.host, &c.window, c.arg("uri")?).await });
d.add(
"doc_language",
|c| async move { doc_language(&c.host, &c.window, c.arg("path")?, c.arg("firstLine")?).await },
);
d.add("doc_ui_mode", |c| async move { doc_ui_mode(&c.host, &c.window, c.arg("path")?).await });
d.add("doc_set_encoding", |c| async move {
doc_set_encoding(&c.host, &c.window, c.arg("doc")?, c.arg("encoding")?, c.arg("reload")?).await
});
-2
Переглянути файл
@@ -33,7 +33,6 @@ pub mod sdk;
pub mod search;
pub mod spell;
mod ssh;
pub mod stream_trace;
pub mod syntax;
pub mod term;
pub mod tools;
@@ -89,7 +88,6 @@ pub fn register_all(d: &mut crate::rpc::Dispatcher) {
java::register(d);
debug::register(d);
heap::register(d);
stream_trace::register(d);
bytes::register(d);
vcs::register(d);
doc::register(d);
+27 -35
Переглянути файл
@@ -208,52 +208,41 @@ pub async fn nav_index_definitions(
}
/// Every Python class in the project (attached dependency roots included) and its base
/// names, answered from the project index: its symbols already carry the bases, and it
/// covers content roots, so this is the whole-project answer the UI uses for inheritance
/// gutter markers when no type-hierarchy provider exists. No file is parsed here.
/// names. The index covers content roots, so this is the whole-project answer the UI uses
/// for inheritance gutter markers when no type-hierarchy provider exists.
pub async fn nav_inheritance(host: &Host, window: &str) -> IdeResult<Vec<ClassInheritance>> {
let project = host.project(window)?;
let syntax = host.syntax();
blocking(move || {
let python = LanguageId::new("python");
let files = project.index.files_with_extensions(&["py".into(), "pyi".into()], 20_000);
let mut cache = CLASS_BASES.lock();
// Disk-backed classes come from the index: it already parsed every file once for
// symbols, so no second parse of the project is needed here.
let mut out: Vec<ClassInheritance> = project
.index
.inheritance()
.into_iter()
// The index holds classes of every language; the graph is Python's.
.filter(|c| matches!(c.path.extension().and_then(std::ffi::OsStr::to_str), Some("py" | "pyi")))
.map(|c| ClassInheritance {
path: IpcPath::from(c.path.clone()),
line: c.range.start.line,
col: c.range.start.col,
name: c.name.clone(),
bases: c.bases.clone(),
})
.collect();
// Open buffers may be unsaved, so their classes are parsed live (and cached per
// text/stamp) and replace the index's view of that file. This keeps #3359's
// "open buffer by its text" behaviour while the disk path is index-backed.
let open_files: Vec<PathBuf> = project
.index
.files_with_extensions(&["py".into(), "pyi".into()], 20_000)
.into_iter()
.filter(|path| project.documents.text_of(path).is_some())
.collect();
for path in open_files {
let mut out = Vec::new();
for path in files {
// The open (possibly unsaved) buffer is keyed by its text, a file on disk by its
// size and modification time, so only changed files are parsed again.
let open = project.documents.text_of(&path);
let stamp = match &open {
Some(text) => Stamp(text_hash(text)),
None => continue,
Some(text) => Stamp::Text(text_hash(text)),
None => match std::fs::metadata(&path) {
Ok(m) => Stamp::Disk(m.len(), m.modified().ok()),
Err(_) => continue,
},
};
let text = open.unwrap();
let classes = match cache.get(&path) {
Some((cached, classes)) if *cached == stamp => classes,
_ => &cache.entry(path.clone()).insert_entry((stamp, syntax.class_bases(&python, &text))).into_mut().1,
_ => {
let text = match open {
Some(text) => text,
None => match project.text_of(&path) {
Ok(text) => text,
Err(_) => continue,
},
};
let classes = syntax.class_bases(&python, &text);
&cache.entry(path.clone()).insert_entry((stamp, classes)).into_mut().1
}
};
out.retain(|c| c.path.0 != *path);
out.extend(classes.iter().map(|class| ClassInheritance {
path: IpcPath::from(path.clone()),
line: class.line,
@@ -268,7 +257,10 @@ pub async fn nav_inheritance(host: &Host, window: &str) -> IdeResult<Vec<ClassIn
}
#[derive(Clone, PartialEq, Eq)]
struct Stamp(u64);
enum Stamp {
Text(u64),
Disk(u64, Option<std::time::SystemTime>),
}
fn text_hash(text: &str) -> u64 {
use std::hash::{Hash, Hasher};
-25
Переглянути файл
@@ -301,8 +301,6 @@ async fn start_inner(
if config.command.is_empty() {
return Err(IdeError::invalid("run configuration has no command"));
}
let on_target = config.extras.target.as_deref().is_some_and(|t| !t.is_empty());
add_java_agents(&mut config, &on_output, !on_target);
// Settings › Run Targets: over SSH, or in a container.
if config.kind == "tomcat" && config.extras.target.as_deref().is_some_and(|t| !t.is_empty()) {
return Err(IdeError::invalid("Tomcat Local requires the local machine"));
@@ -448,29 +446,6 @@ async fn start_inner(
host.processes.start(&project.root, &config, &options, sink, Box::new(move |c| on_output(c)))
}
/// Plugins' Java agents (`[[contributes.javaAgents]]`, granted `java.agent`) for the JVM of an
/// Application, Spring Boot or JAR Application configuration started on this machine. A JVM on a
/// run target gets none; the console says so, and why an approved agent was left out.
fn add_java_agents(config: &mut RunConfig, on_output: &Emit<OutputChunk>, local: bool) {
if !ide_run::java_agent::applies(&config.kind) {
return;
}
let agents = ide_run::java_agent::current();
let say = |text: &str| on_output(OutputChunk::System { text: format!("{text}\n") });
if !local {
if !agents.options.is_empty() {
say(
"Plugin Java agents were not added: they load only into JVMs started on this machine, not on a run target.",
);
}
return;
}
for note in &agents.notes {
say(note);
}
ide_run::java_agent::add_to_args(&mut config.args, &agents.options);
}
/// The Ruby test reporter's directory, installed on demand, for runs that take it.
fn ruby_reporter_dir(host: &Host, config: &RunConfig) -> Option<std::path::PathBuf> {
if !ide_run::ruby_reporter::applies(config) {
-1
Переглянути файл
@@ -65,7 +65,6 @@ pub async fn spell_check(
end: r.end,
kind: match r.kind {
SpellingKind::Comment => RegionKind::Comment,
SpellingKind::String if r.raw => RegionKind::RawString,
SpellingKind::String => RegionKind::String,
SpellingKind::Name => RegionKind::Name,
},
-466
Переглянути файл
@@ -1,466 +0,0 @@
//! Java Stream Debugger: the stream chains around a debugger stop, and traces of a chain's real run.
//! `ide_streams` finds the chains and links what the run recorded; `ide_dap` runs the trace.
use crate::Host;
use crate::ops::Channel;
use crate::rpc::Dispatcher;
use ide_core::{CancellationToken, DebugSessionId, IdeError, IdeResult, LanguageId, Range, RequestId};
use ide_dap::{StackFrame, TraceRun};
pub use ide_dap::{TracePhase, TraceProgress, TraceUnavailable};
pub use ide_jvm_inspect::{AbortState, JvmValue};
use ide_jvm_inspect::{CollectedTerminal, TraceCollected};
use ide_streams::{
BoxKind, RealRunPlan, RealRunRefusal, Record, Rejection, StopContext, StreamChain, TerminalOutcome, TraceRecording,
TraceValue, find_chains, link_trace, real_run_plan, recorded_steps,
};
pub use ide_streams::{Link, TraceBanner};
use ide_syntax::{Snapshot, StructureService};
use serde::{Deserialize, Serialize};
use specta::Type;
use std::path::Path;
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct StreamChainInfo {
/// The `chain_index` [`debug_stream_trace`] takes for the same frame.
pub index: u32,
pub range: Range,
pub text: String,
/// Intermediate operations in call order, modifiers included. Empty, like `terminal`, for a
/// chain the search rejected.
pub steps: Vec<String>,
pub terminal: String,
pub available: bool,
/// Set exactly when `available` is false.
#[serde(default, skip_serializing_if = "Option::is_none")]
#[specta(optional)]
pub reason: Option<ChainUnavailable>,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
pub enum ChainUnavailable {
NotTopFrame,
NotAtChainStart,
InsideChainLambda,
NotJavaStreamRoot {
root: String,
},
LazyTerminal {
op: String,
},
NoTerminal,
UnknownOperation {
op: String,
},
SyntaxError,
/// The session has no stream tracer: not java-debug, or its jdtls has no inspector bundle.
NoBackend,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "status", rename_all = "camelCase", rename_all_fields = "camelCase")]
pub enum StreamTraceResult {
Ready {
chain: Box<StreamChainInfo>,
/// Column titles by recorded step: `steps[0]` is the root call's name (empty for a stream
/// held in a local), then each operation that records, modifiers left out.
steps: Vec<String>,
/// In recording order.
records: Vec<TraceRecordView>,
/// Parallel to `records`.
links: Vec<Link>,
terminal: TerminalView,
banners: Vec<TraceBanner>,
/// The stop the values belong to, for `debug_jvm_memory_fields`.
generation: u64,
},
Unavailable {
reason: TraceUnavailable,
},
Failed {
detail: String,
},
/// Recording was stopped, or the operation aborted, before the chain ran: nothing went wrong.
Cancelled {
detail: String,
},
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct TraceRecordView {
pub step: u16,
pub value: JvmValue,
}
#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
pub enum TerminalView {
Value { value: JvmValue },
Void,
Threw { exception: JvmValue },
}
/// The stream chains around `frame`'s line, in source order, with why each cannot be traced.
/// `top`: `frame` is the thread's top frame, the only one a trace can run from.
pub async fn debug_stream_chains(
host: &Host,
window: &str,
session: DebugSessionId,
frame: StackFrame,
top: bool,
) -> IdeResult<Vec<StreamChainInfo>> {
host.require_trust(window)?;
let backend = host.debugger.capabilities(session)?.stream_trace;
Ok(candidates(host, window, frame, top, backend).await?.into_iter().map(|c| c.info).collect())
}
/// Runs the program from `thread_id`, stopped in `frame`, through the chain `chain_index` of
/// [`debug_stream_chains`], recording each element, and leaves it stopped after the chain's
/// terminal operation. `range` is that chain's [`StreamChainInfo::range`]: an edit in between
/// can move another chain to the same index. Cancelling `request` stops recording while the
/// program runs on.
#[allow(clippy::too_many_arguments)]
pub async fn debug_stream_trace(
host: &Host,
window: &str,
session: DebugSessionId,
request: RequestId,
thread_id: i64,
frame: StackFrame,
chain_index: u32,
range: Range,
on_progress: Channel<TraceProgress>,
) -> IdeResult<StreamTraceResult> {
host.require_trust(window)?;
let cancel = host.begin_project_request(window, request);
let chain = ChainRef { frame, index: chain_index, range };
let result = trace(host, window, session, thread_id, chain, &cancel, &on_progress).await;
host.end_request(request);
result
}
/// The chain the UI chose, as [`debug_stream_chains`] listed it.
struct ChainRef {
frame: StackFrame,
index: u32,
range: Range,
}
async fn trace(
host: &Host,
window: &str,
session: DebugSessionId,
thread_id: i64,
chosen: ChainRef,
cancel: &CancellationToken,
on_progress: &Channel<TraceProgress>,
) -> IdeResult<StreamTraceResult> {
let line = chosen.frame.line;
// `stream_trace` decides whether the session can trace, so the backend is assumed here.
let candidate = candidates(host, window, chosen.frame, true, true)
.await?
.into_iter()
.nth(chosen.index as usize)
.filter(|c| c.info.range == chosen.range);
let Some(candidate) = candidate else {
return Ok(StreamTraceResult::Failed { detail: "the chain changed; trace it again".into() });
};
if let Some(reason) = candidate.info.reason.clone() {
let reason = trace_unavailable(reason, line, candidate.chain.as_ref());
return Ok(StreamTraceResult::Unavailable { reason });
}
let Some(chain) = candidate.chain else {
return Err(IdeError::internal("an available stream chain has no parsed chain"));
};
let plan = real_run_plan(&chain).map_err(|e| IdeError::internal(format!("stream chain plan: {e:?}")))?;
let plan_json = serde_json::to_value(&plan).map_err(|e| IdeError::internal(e.to_string()))?;
// `stream_trace` resumes the program before it looks at `cancel`.
if cancel.is_cancelled() {
return Ok(StreamTraceResult::Cancelled { detail: "cancelled before the trace started".into() });
}
let progress = |p| {
let _ = on_progress.send(p);
};
let run = host.debugger.stream_trace(session, thread_id, plan_json, cancel.clone(), progress).await?;
Ok(match run {
TraceRun::Done { collected, generation, resumed_stops } => {
let info = candidate.info;
host.blocking(move || Ok(ready(info, &chain, &plan, collected, generation, resumed_stops))).await?
}
TraceRun::Unavailable { reason } => StreamTraceResult::Unavailable { reason },
TraceRun::Failed { detail } => StreamTraceResult::Failed { detail },
TraceRun::Cancelled { detail } => StreamTraceResult::Cancelled { detail },
})
}
/// Ends the running trace's terminal operation (Abort Operation); `None` when no trace runs.
pub async fn debug_stream_trace_abort(
host: &Host,
window: &str,
session: DebugSessionId,
) -> IdeResult<Option<AbortState>> {
host.require_trust(window)?;
host.debugger.stream_trace_abort(session).await
}
struct Candidate {
info: StreamChainInfo,
/// `None` for a chain the search rejected.
chain: Option<StreamChain>,
}
/// The file's current text (the open buffer, else the disk) searched off the command thread.
/// Frames outside readable Java sources have no chains: java-debug gives library frames
/// `jdt://contents/…` paths.
async fn candidates(
host: &Host,
window: &str,
frame: StackFrame,
top: bool,
backend: bool,
) -> IdeResult<Vec<Candidate>> {
let Some(path) = frame.path.clone() else { return Ok(Vec::new()) };
let project = host.project(window)?;
host.blocking(move || {
let path = path.into_path_buf();
let cancel = CancellationToken::new();
let search = |snap: &Snapshot| {
if snap.language.as_str() != "java" {
return Ok(Vec::new());
}
chains_at(&project.structure, snap, &frame, top, backend, &cancel)
};
if let Some(doc) = project.documents.by_path(&path) {
let snap = project.documents.text_snapshot(doc)?;
if snap.large {
return Err(IdeError::unavailable("file is too large for syntax analysis"));
}
return search(&Snapshot::doc(doc, snap.version, &snap.language, &snap.text));
}
let language: LanguageId = project.languages.detect(&path, None);
if language.as_str() != "java" {
return Ok(Vec::new());
}
let Ok(text) = project.text_of(&path) else { return Ok(Vec::new()) };
search(&Snapshot::text(&language, &text))
})
.await
}
fn chains_at(
service: &StructureService,
snap: &Snapshot,
frame: &StackFrame,
top: bool,
backend: bool,
cancel: &CancellationToken,
) -> IdeResult<Vec<Candidate>> {
let path = frame.path.as_ref().map(|p| p.0.as_path());
let file_stem = path.and_then(Path::file_stem).and_then(|s| s.to_str()).unwrap_or_default();
let stop = StopContext { line: frame.line, in_lambda: frame.name.contains("lambda$"), file_stem };
let found = find_chains(service, snap, &stop, cancel)?;
let mut candidates: Vec<Candidate> = found
.chains
.into_iter()
.map(|chain| {
let reason = refusal(&chain, frame.line, top, backend);
let info = StreamChainInfo {
index: 0,
range: chain.range,
text: chain.text.clone(),
steps: chain.ops.iter().map(|op| op.name.clone()).collect(),
terminal: chain.terminal.name.clone(),
available: reason.is_none(),
reason,
};
Candidate { info, chain: Some(chain) }
})
.collect();
candidates.extend(found.rejected.into_iter().map(|rejected| {
let reason = if top { rejection(rejected.reason) } else { ChainUnavailable::NotTopFrame };
let info = StreamChainInfo {
index: 0,
range: rejected.range,
text: rejected.text,
steps: Vec::new(),
terminal: String::new(),
available: false,
reason: Some(reason),
};
Candidate { info, chain: None }
}));
candidates.sort_by_key(|c| c.info.range);
for (i, c) in candidates.iter_mut().enumerate() {
c.info.index = i as u32;
}
Ok(candidates)
}
fn refusal(chain: &StreamChain, line: u32, top: bool, backend: bool) -> Option<ChainUnavailable> {
if !top {
return Some(ChainUnavailable::NotTopFrame);
}
// ECJ puts the first instruction of `T x =\n root…` on the root's line, not the
// statement's; the bundle makes the final call from the line table.
if line < chain.first_line || line > root_line(chain) {
return Some(ChainUnavailable::NotAtChainStart);
}
if let Err(refused) = real_run_plan(chain) {
return Some(refusal_reason(refused));
}
(!backend).then_some(ChainUnavailable::NoBackend)
}
fn root_line(chain: &StreamChain) -> u32 {
let before_root = chain.text.get(..chain.root.span.0).unwrap_or_default();
chain.range.start.line + before_root.matches('\n').count() as u32
}
fn refusal_reason(refused: RealRunRefusal) -> ChainUnavailable {
match refused {
RealRunRefusal::NotJavaStreamRoot { root } => ChainUnavailable::NotJavaStreamRoot { root },
RealRunRefusal::LazyTerminal { op } => ChainUnavailable::LazyTerminal { op },
RealRunRefusal::NoTerminal => ChainUnavailable::NoTerminal,
RealRunRefusal::UnknownOperation { op } => ChainUnavailable::UnknownOperation { op },
RealRunRefusal::InsideChainLambda => ChainUnavailable::InsideChainLambda,
RealRunRefusal::SyntaxError => ChainUnavailable::SyntaxError,
}
}
fn rejection(rejected: Rejection) -> ChainUnavailable {
match rejected {
Rejection::LazyTerminal { op } => ChainUnavailable::LazyTerminal { op },
Rejection::NoTerminal => ChainUnavailable::NoTerminal,
Rejection::UnknownOperation { op } => ChainUnavailable::UnknownOperation { op },
Rejection::InsideChainLambda => ChainUnavailable::InsideChainLambda,
Rejection::SyntaxError => ChainUnavailable::SyntaxError,
}
}
/// The same reasons as the bundle's refusals, for a chain that stopped being traceable between
/// [`debug_stream_chains`] and [`debug_stream_trace`].
fn trace_unavailable(reason: ChainUnavailable, line: u32, chain: Option<&StreamChain>) -> TraceUnavailable {
let unsupported = |detail: String| TraceUnavailable::Unsupported { detail };
match reason {
ChainUnavailable::NotAtChainStart => {
let start = chain.map_or(String::new(), |c| format!(", the chain starts on line {}", c.first_line + 1));
TraceUnavailable::NotAtChainStart { detail: format!("the stop is on line {}{start}", line + 1) }
}
ChainUnavailable::NoBackend => TraceUnavailable::NoBackend,
ChainUnavailable::NotTopFrame => unsupported("only the top frame can be traced".into()),
ChainUnavailable::InsideChainLambda => unsupported("the chain is already running".into()),
ChainUnavailable::NotJavaStreamRoot { root } => {
unsupported(format!("the stream {root} does not start in this statement"))
}
ChainUnavailable::LazyTerminal { op } => unsupported(format!("{op}() does not run the pipeline")),
ChainUnavailable::NoTerminal => unsupported("the chain has no terminal operation".into()),
ChainUnavailable::UnknownOperation { op } => unsupported(format!("unknown stream operation {op}()")),
ChainUnavailable::SyntaxError => unsupported("the statement does not parse".into()),
}
}
fn ready(
chain_info: StreamChainInfo,
chain: &StreamChain,
plan: &RealRunPlan,
collected: TraceCollected,
generation: u64,
resumed_stops: u32,
) -> StreamTraceResult {
let recording = TraceRecording {
records: collected.records.iter().map(|(step, v)| Record { step: *step, value: trace_value(v) }).collect(),
dropped: collected.dropped,
terminal: match &collected.terminal {
CollectedTerminal::Value(v) => TerminalOutcome::Value { value: trace_value(v) },
CollectedTerminal::Void => TerminalOutcome::Void,
CollectedTerminal::Threw(e) => TerminalOutcome::Threw { exception: trace_value(e) },
},
};
let mut linked = link_trace(plan, &recording, collected.skipped_breakpoints);
// A stream made parallel before the chain's statement, which the bundle found so at run time.
if collected.sequentialized && !plan.sequentialize {
linked.banners.push(TraceBanner::Sequentialized);
}
if resumed_stops > 0 {
linked.banners.push(TraceBanner::BreakpointsResumed { count: resumed_stops });
}
StreamTraceResult::Ready {
chain: Box::new(chain_info),
steps: recorded_steps(chain),
records: collected.records.into_iter().map(|(step, value)| TraceRecordView { step, value }).collect(),
links: linked.links,
terminal: match collected.terminal {
CollectedTerminal::Value(value) => TerminalView::Value { value },
CollectedTerminal::Void => TerminalView::Void,
CollectedTerminal::Threw(exception) => TerminalView::Threw { exception },
},
banners: linked.banners,
generation,
}
}
fn trace_value(value: &JvmValue) -> TraceValue {
match value {
JvmValue::Null => TraceValue::Null,
JvmValue::Boxed { id, type_name, text } => match box_kind(type_name) {
Some(class) => TraceValue::Boxed { id: *id, class, value: text.clone() },
None => TraceValue::Object { id: *id, class: type_name.clone() },
},
JvmValue::Str { id, text, .. } => {
TraceValue::Str { id: *id, value: text.clone().unwrap_or_default(), truncated: text.is_none() }
}
JvmValue::Object { id, type_name } | JvmValue::Array { id, type_name, .. } => {
TraceValue::Object { id: *id, class: type_name.clone() }
}
// The recorder boxes every element, so only a terminal's result is primitive, and linking
// never reads that.
JvmValue::Primitive { type_name, text } => match box_kind(type_name) {
Some(class) => TraceValue::Boxed { id: 0, class, value: text.clone() },
None => TraceValue::Null,
},
}
}
/// Wrapper class names (boxed values) and primitive type names (primitive values) alike.
fn box_kind(type_name: &str) -> Option<BoxKind> {
Some(match type_name {
"java.lang.Boolean" | "boolean" => BoxKind::Boolean,
"java.lang.Byte" | "byte" => BoxKind::Byte,
"java.lang.Character" | "char" => BoxKind::Char,
"java.lang.Short" | "short" => BoxKind::Short,
"java.lang.Integer" | "int" => BoxKind::Int,
"java.lang.Long" | "long" => BoxKind::Long,
"java.lang.Float" | "float" => BoxKind::Float,
"java.lang.Double" | "double" => BoxKind::Double,
_ => return None,
})
}
/// Commands of this module the remote server answers.
pub(crate) fn register(d: &mut Dispatcher) {
d.add("debug_stream_chains", |c| async move {
debug_stream_chains(&c.host, &c.window, c.arg("session")?, c.arg("frame")?, c.arg("top")?).await
});
d.add("debug_stream_trace", |c| async move {
debug_stream_trace(
&c.host,
&c.window,
c.arg("session")?,
c.arg("request")?,
c.arg("threadId")?,
c.arg("frame")?,
c.arg("chainIndex")?,
c.arg("range")?,
c.sender("onProgress")?,
)
.await
});
d.add("debug_stream_trace_abort", |c| async move {
debug_stream_trace_abort(&c.host, &c.window, c.arg("session")?).await
});
}
#[cfg(test)]
mod tests;
-461
Переглянути файл
@@ -1,461 +0,0 @@
use super::*;
use ide_core::{CancellationToken, LanguageId};
use ide_language::{Syntax, SyntaxCache};
use ide_streams::BoxKind;
use serde_json::json;
use std::sync::{Arc, OnceLock};
const SOURCE: &str = r#"import java.util.*;
import java.util.stream.*;
class Chains {
Stream<Integer> items;
void run(List<Integer> nums) {
List<Integer> evens = nums.stream() // C_EVENS
.filter(x -> x % 2 == 0) // C_EVENS_FILTER
.collect(Collectors.toList());
List<Integer> out = // C_DECL
nums.stream() // C_ROOT
.map(x -> x + 1) // C_ROOT_MAP
.collect(Collectors.toList());
long n = this.items.filter(x -> x > 0).count(); // C_FIELD
Iterator<Integer> it = nums.stream().map(x -> x).iterator(); // C_LAZY
List<String> a = nums.stream().filter(x -> x % 2 == 0).map(x -> x * 10 + 1).sorted().map(String::valueOf).collect(Collectors.toList()); // C_SPIKE
}
}
"#;
fn service() -> &'static StructureService {
static S: OnceLock<StructureService> = OnceLock::new();
S.get_or_init(|| StructureService::new(Arc::new(SyntaxCache::new(Arc::new(Syntax::new())))))
}
fn line_of(marker: &str) -> u32 {
let tag = format!("// {marker}");
let found = SOURCE.lines().position(|l| l.trim_end().ends_with(&tag));
found.unwrap_or_else(|| panic!("no line marked {marker}")) as u32
}
fn frame(line: u32) -> StackFrame {
StackFrame {
id: 1,
name: "Chains.run(List)".into(),
path: Some("/project/src/Chains.java".into()),
line,
column: 8,
presentation_hint: None,
}
}
fn chains_on(line: u32, top: bool, backend: bool) -> Vec<StreamChainInfo> {
let java = LanguageId::new("java");
let snap = Snapshot::text(&java, SOURCE);
let found = chains_at(service(), &snap, &frame(line), top, backend, &CancellationToken::new()).expect("search");
found.into_iter().map(|c| c.info).collect()
}
fn availability(info: &StreamChainInfo) -> serde_json::Value {
let mut v = serde_json::to_value(info).unwrap();
let map = v.as_object_mut().unwrap();
json!({ "available": map.remove("available"), "reason": map.remove("reason") })
}
#[test]
fn chains_refuse_non_top_frame() {
let infos = chains_on(line_of("C_EVENS"), false, true);
assert!(!infos.is_empty());
for info in &infos {
assert_eq!(availability(info), json!({"available": false, "reason": {"kind": "notTopFrame"}}), "{info:?}");
}
}
#[test]
fn chains_need_first_line() {
let infos = chains_on(line_of("C_EVENS_FILTER"), true, true);
assert_eq!(infos.len(), 1, "{infos:?}");
assert_eq!(availability(&infos[0]), json!({"available": false, "reason": {"kind": "notAtChainStart"}}));
let mid = chains_on(line_of("C_ROOT_MAP"), true, true);
assert_eq!(availability(&mid[0]), json!({"available": false, "reason": {"kind": "notAtChainStart"}}));
}
/// ECJ puts a declaration's first instruction on the line of its initializer's root call.
#[test]
fn chains_accept_the_root_line_of_a_declaration() {
let at_root = chains_on(line_of("C_ROOT"), true, true);
assert_eq!(at_root.len(), 1, "{at_root:?}");
assert_eq!(availability(&at_root[0]), json!({"available": true, "reason": null}));
let at_head = chains_on(line_of("C_DECL"), true, true);
assert_eq!(availability(&at_head[0]), json!({"available": true, "reason": null}));
}
#[test]
fn chains_list_rejections() {
let field = chains_on(line_of("C_FIELD"), true, true);
assert_eq!(field.len(), 1, "{field:?}");
assert_eq!(
availability(&field[0]),
json!({"available": false, "reason": {"kind": "notJavaStreamRoot", "root": "this.items"}})
);
let lazy = chains_on(line_of("C_LAZY"), true, true);
assert_eq!(lazy.len(), 1, "{lazy:?}");
assert_eq!(
availability(&lazy[0]),
json!({"available": false, "reason": {"kind": "lazyTerminal", "op": "iterator"}})
);
}
#[test]
fn chains_without_a_tracer_have_no_backend() {
let infos = chains_on(line_of("C_EVENS"), true, false);
assert_eq!(availability(&infos[0]), json!({"available": false, "reason": {"kind": "noBackend"}}));
}
#[test]
fn chain_info_json_shape() {
let infos = chains_on(line_of("C_EVENS"), true, true);
let v = serde_json::to_value(&infos[0]).unwrap();
assert_eq!(v["index"], 0);
assert_eq!(v["steps"], json!(["filter"]));
assert_eq!(v["terminal"], "collect");
assert_eq!(v["range"]["start"]["line"], line_of("C_EVENS"));
assert_eq!(v["available"], true);
assert!(v.get("reason").is_none(), "{v}");
}
#[test]
fn jvm_value_to_trace_value() {
let boxed = JvmValue::Boxed { id: 4, type_name: "java.lang.Integer".into(), text: "8".into() };
assert_eq!(trace_value(&boxed), TraceValue::Boxed { id: 4, class: BoxKind::Int, value: "8".into() });
let long_text = JvmValue::Str { id: 5, text: None, length: 50_000 };
assert_eq!(trace_value(&long_text), TraceValue::Str { id: 5, value: String::new(), truncated: true });
let short_text = JvmValue::Str { id: 6, text: Some("81".into()), length: 2 };
assert_eq!(trace_value(&short_text), TraceValue::Str { id: 6, value: "81".into(), truncated: false });
let object = JvmValue::Object { id: 7, type_name: "com.x.Order".into() };
assert_eq!(trace_value(&object), TraceValue::Object { id: 7, class: "com.x.Order".into() });
let array = JvmValue::Array { id: 8, type_name: "int[]".into(), length: 3 };
assert_eq!(trace_value(&array), TraceValue::Object { id: 8, class: "int[]".into() });
assert_eq!(trace_value(&JvmValue::Null), TraceValue::Null);
let odd_box = JvmValue::Boxed { id: 9, type_name: "java.math.BigInteger".into(), text: "1".into() };
assert_eq!(trace_value(&odd_box), TraceValue::Object { id: 9, class: "java.math.BigInteger".into() });
let count = JvmValue::Primitive { type_name: "long".into(), text: "4".into() };
assert_eq!(trace_value(&count), TraceValue::Boxed { id: 0, class: BoxKind::Long, value: "4".into() });
let odd_primitive = JvmValue::Primitive { type_name: "void".into(), text: String::new() };
assert_eq!(trace_value(&odd_primitive), TraceValue::Null);
}
/// The log measured on `source -> filter -> map -> sorted -> map` (see ide-streams' spike test),
/// as the bundle reports it: every `peek` re-boxes, so no two boxes share an id.
fn spike_collected() -> TraceCollected {
let steps_values: [(u16, &str); 24] = [
(0, "5"),
(0, "3"),
(0, "8"),
(1, "8"),
(2, "81"),
(0, "1"),
(0, "4"),
(1, "4"),
(2, "41"),
(0, "2"),
(1, "2"),
(2, "21"),
(0, "9"),
(0, "6"),
(1, "6"),
(2, "61"),
(3, "21"),
(4, "21"),
(3, "41"),
(4, "41"),
(3, "61"),
(4, "61"),
(3, "81"),
(4, "81"),
];
let records = steps_values
.iter()
.enumerate()
.map(|(i, &(step, text))| {
let id = 100 + i as u64;
let value = if step == 4 {
JvmValue::Str { id, text: Some(text.into()), length: text.len() as u32 }
} else {
JvmValue::Boxed { id, type_name: "java.lang.Integer".into(), text: text.into() }
};
(step, value)
})
.collect();
TraceCollected {
records,
dropped: 3,
terminal: CollectedTerminal::Value(JvmValue::Object { id: 7, type_name: "java.util.ArrayList".into() }),
skipped_breakpoints: 2,
sequentialized: false,
}
}
#[test]
fn ready_links_the_collected_records() {
let java = LanguageId::new("java");
let snap = Snapshot::text(&java, SOURCE);
let found = chains_at(service(), &snap, &frame(line_of("C_SPIKE")), true, true, &CancellationToken::new()).unwrap();
let Candidate { info, chain } = found.into_iter().next().unwrap();
let chain = chain.unwrap();
let plan = real_run_plan(&chain).unwrap();
let collected = spike_collected();
let expected_records: Vec<TraceRecordView> =
collected.records.iter().map(|(step, value)| TraceRecordView { step: *step, value: value.clone() }).collect();
let StreamTraceResult::Ready { chain: shown, steps, records, links, terminal, banners, generation } =
ready(info.clone(), &chain, &plan, collected, 9, 0)
else {
panic!("not ready");
};
assert_eq!(*shown, info);
assert_eq!(steps, ["stream", "filter", "map", "sorted", "map"]);
assert_eq!(records, expected_records);
assert_eq!(links.len(), records.len());
assert_eq!(links[0], Link { parent: None, ambiguous: false });
// `1=8` comes from the `0=8` just before it, and `2=81` from that.
assert_eq!(links[3].parent, Some(2));
assert_eq!(links[4].parent, Some(3));
// `sorted` emits `3=21` after the whole upstream ran: it is the `2=21` of record 11, linked by
// value although the box was re-made.
assert_eq!(links[16], Link { parent: Some(11), ambiguous: false });
assert_eq!(links[17].parent, Some(16));
assert_eq!(links[22].parent, Some(4));
assert_eq!(
terminal,
TerminalView::Value { value: JvmValue::Object { id: 7, type_name: "java.util.ArrayList".into() } }
);
assert_eq!(banners, [TraceBanner::Truncated { dropped: 3 }, TraceBanner::BreakpointsSkipped { count: 2 }]);
assert_eq!(generation, 9);
}
#[test]
fn ready_says_how_many_stops_were_resumed() {
let java = LanguageId::new("java");
let snap = Snapshot::text(&java, SOURCE);
let found = chains_at(service(), &snap, &frame(line_of("C_SPIKE")), true, true, &CancellationToken::new()).unwrap();
let Candidate { info, chain } = found.into_iter().next().unwrap();
let chain = chain.unwrap();
let plan = real_run_plan(&chain).unwrap();
let StreamTraceResult::Ready { banners, .. } = ready(info, &chain, &plan, spike_collected(), 9, 3) else {
panic!("not ready");
};
assert_eq!(
banners,
[
TraceBanner::Truncated { dropped: 3 },
TraceBanner::BreakpointsSkipped { count: 2 },
TraceBanner::BreakpointsResumed { count: 3 }
]
);
}
const WINDOW: &str = "main";
/// A real `Host` with a trusted project holding `src/Chains.java` (= [`SOURCE`]).
struct Fixture {
host: Host,
source: std::path::PathBuf,
_temp: tempfile::TempDir,
}
impl Fixture {
async fn new() -> Self {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let root = base.join("project");
std::fs::create_dir_all(root.join("src")).unwrap();
let source = root.join("src/Chains.java");
std::fs::write(&source, SOURCE).unwrap();
let host = Host::new(crate::HostConfig {
config_dir: base.join("config"),
data_dir: base.join("data"),
local_data_dir: base.join("local"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(|_| Arc::new(|_| {})),
owner: |w| w,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
});
host.open_project(WINDOW, &root).unwrap();
host.set_project_trust(&root, true, false).await.unwrap();
Self { host, source, _temp: temp }
}
fn frame(&self, line: u32) -> StackFrame {
StackFrame { path: Some(self.source.as_path().into()), ..frame(line) }
}
async fn chains(&self, frame: StackFrame) -> Vec<StreamChainInfo> {
candidates(&self.host, WINDOW, frame, true, true).await.unwrap().into_iter().map(|c| c.info).collect()
}
async fn trace(&self, request: u32, frame: StackFrame, index: u32, range: Range) -> StreamTraceResult {
let request = RequestId(request);
debug_stream_trace(
&self.host,
WINDOW,
DebugSessionId(404),
request,
1,
frame,
index,
range,
Channel::new(|_| {}),
)
.await
.unwrap()
}
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn chains_skip_frames_without_a_readable_java_source() {
let f = Fixture::new().await;
assert_eq!(f.chains(f.frame(line_of("C_EVENS"))).await.len(), 1, "the file on disk is read");
let library = StackFrame {
path: Some("jdt://contents/rt.jar/java.util.stream/ReferencePipeline.class?=java/rt.jar".into()),
..frame(120)
};
assert_eq!(f.chains(library).await, []);
let missing = StackFrame { path: Some(f.source.with_file_name("Missing.java").as_path().into()), ..frame(3) };
assert_eq!(f.chains(missing).await, []);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn trace_refuses_a_chain_that_changed() {
let f = Fixture::new().await;
let at = f.frame(line_of("C_EVENS"));
let listed = f.chains(at.clone()).await.remove(0);
let changed = StreamTraceResult::Failed { detail: "the chain changed; trace it again".into() };
let mut moved = listed.range;
moved.end.col += 1;
assert_eq!(f.trace(1, at.clone(), listed.index, moved).await, changed);
assert_eq!(f.trace(2, at, listed.index + 1, listed.range).await, changed);
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn trace_reports_an_unavailable_chain_like_the_bundle() {
let f = Fixture::new().await;
let mid = f.frame(line_of("C_EVENS_FILTER"));
let listed = f.chains(mid.clone()).await.remove(0);
let detail = format!(
"the stop is on line {}, the chain starts on line {}",
line_of("C_EVENS_FILTER") + 1,
line_of("C_EVENS") + 1
);
assert_eq!(
f.trace(1, mid, listed.index, listed.range).await,
StreamTraceResult::Unavailable { reason: TraceUnavailable::NotAtChainStart { detail } }
);
let field = f.frame(line_of("C_FIELD"));
let listed = f.chains(field.clone()).await.remove(0);
let detail = "the stream this.items does not start in this statement".to_string();
assert_eq!(
f.trace(2, field, listed.index, listed.range).await,
StreamTraceResult::Unavailable { reason: TraceUnavailable::Unsupported { detail } }
);
}
/// The session id names no session: reaching `stream_trace` would fail the call.
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn trace_cancelled_before_it_starts_does_not_run() {
let f = Fixture::new().await;
let at = f.frame(line_of("C_EVENS"));
let listed = f.chains(at.clone()).await.remove(0);
f.host.cancel_request(RequestId(7));
assert_eq!(
f.trace(7, at, listed.index, listed.range).await,
StreamTraceResult::Cancelled { detail: "cancelled before the trace started".into() }
);
assert_eq!(
serde_json::to_value(StreamTraceResult::Cancelled { detail: "x".into() }).unwrap(),
json!({"status": "cancelled", "detail": "x"})
);
}
#[test]
fn ready_result_json_shape() {
let info = chains_on(line_of("C_EVENS"), true, true).remove(0);
let value = JvmValue::Boxed { id: 4, type_name: "java.lang.Integer".into(), text: "8".into() };
let ready = StreamTraceResult::Ready {
chain: Box::new(info),
steps: vec!["stream".into(), "filter".into()],
records: vec![TraceRecordView { step: 0, value: value.clone() }],
links: vec![Link { parent: None, ambiguous: false }],
terminal: TerminalView::Threw { exception: JvmValue::Object { id: 9, type_name: "java.lang.X".into() } },
banners: vec![TraceBanner::Truncated { dropped: 2 }, TraceBanner::BreakpointsSkipped { count: 1 }],
generation: 3,
};
let v = serde_json::to_value(&ready).unwrap();
assert_eq!(v["status"], "ready");
assert_eq!(v["chain"]["available"], true);
assert_eq!(v["steps"], json!(["stream", "filter"]));
assert_eq!(
v["records"],
json!([{"step": 0, "value": {"kind": "boxed", "id": 4, "typeName": "java.lang.Integer", "text": "8"}}])
);
assert_eq!(v["links"], json!([{"parent": null, "ambiguous": false}]));
assert_eq!(
v["terminal"],
json!({"kind": "threw", "exception": {"kind": "object", "id": 9, "typeName": "java.lang.X"}})
);
assert_eq!(v["banners"], json!([{"kind": "truncated", "dropped": 2}, {"kind": "breakpointsSkipped", "count": 1}]));
assert_eq!(v["generation"], 3);
assert_eq!(serde_json::to_value(TerminalView::Value { value }).unwrap()["kind"], "value");
assert_eq!(serde_json::to_value(TerminalView::Void).unwrap(), json!({"kind": "void"}));
}
#[test]
fn other_results_json_shape() {
let unavailable =
StreamTraceResult::Unavailable { reason: TraceUnavailable::NotAtChainStart { detail: "line 4".into() } };
assert_eq!(
serde_json::to_value(&unavailable).unwrap(),
json!({"status": "unavailable", "reason": {"kind": "notAtChainStart", "detail": "line 4"}})
);
assert_eq!(
serde_json::to_value(StreamTraceResult::Failed { detail: "boom".into() }).unwrap(),
json!({"status": "failed", "detail": "boom"})
);
let progress = TraceProgress { phase: TracePhase::RecordingStopped, records: 5, dropped: 0, elapsed_ms: 40 };
assert_eq!(
serde_json::to_value(&progress).unwrap(),
json!({"phase": "recordingStopped", "records": 5, "dropped": 0, "elapsedMs": 40})
);
let stuck = AbortState::Stuck { holders: vec![(3, "main".into())] };
assert_eq!(serde_json::to_value(&stuck).unwrap(), json!({"kind": "stuck", "holders": [[3, "main"]]}));
assert_eq!(serde_json::to_value(AbortState::Interrupted).unwrap(), json!({"kind": "interrupted"}));
}
#[test]
fn chain_info_steps_keep_modifiers() {
let java = LanguageId::new("java");
let source = "class Chains { void run(java.util.List<Integer> nums) {\n\
long n = nums.parallelStream().filter(x -> x > 0).unordered().map(x -> x).count();\n} }";
let snap = Snapshot::text(&java, source);
let found = chains_at(service(), &snap, &frame(1), true, true, &CancellationToken::new()).unwrap();
assert_eq!(found[0].info.steps, ["filter", "unordered", "map"]);
}
#[test]
fn ready_says_a_stream_found_parallel_at_run_time_ran_sequentially() {
let java = LanguageId::new("java");
let snap = Snapshot::text(&java, SOURCE);
let found = chains_at(service(), &snap, &frame(line_of("C_SPIKE")), true, true, &CancellationToken::new()).unwrap();
let Candidate { info, chain } = found.into_iter().next().unwrap();
let chain = chain.unwrap();
let plan = real_run_plan(&chain).unwrap();
assert!(!plan.sequentialize);
let collected = TraceCollected { sequentialized: true, ..spike_collected() };
let StreamTraceResult::Ready { banners, .. } = ready(info, &chain, &plan, collected, 9, 0) else {
panic!("not ready");
};
assert!(banners.contains(&TraceBanner::Sequentialized), "{banners:?}");
}
-22
Переглянути файл
@@ -1304,25 +1304,6 @@ pub async fn vcs_create_patch(
.await
}
/// The changes a commit with `options` would make in `repo`, as one patch (what Commit
/// commits: the index with the selection applied, partial files' chosen hunks only).
pub async fn vcs_pending_patch(
host: &Host,
window: &str,
repo: Option<PathBuf>,
options: CommitOptions,
) -> IdeResult<String> {
const MAX_PATCH: usize = 1 << 20;
let project = host.project(window)?;
blocking(move || {
project.with_repo_at(repo.as_deref(), |r| {
let changes = r.pending_changes(&options, MAX_PATCH, &|path| project.vcs_encoding(path, None))?;
Ok(changes.into_iter().filter_map(|c| c.diff).collect())
})
})
.await
}
pub async fn vcs_patch_preview(
host: &Host,
window: &str,
@@ -1682,9 +1663,6 @@ pub(crate) fn register(d: &mut Dispatcher) {
d.add("vcs_create_patch", |c| async move {
vcs_create_patch(&c.host, &c.window, c.arg("repo")?, c.arg("source")?).await
});
d.add("vcs_pending_patch", |c| async move {
vcs_pending_patch(&c.host, &c.window, c.arg("repo")?, c.arg("options")?).await
});
d.add("vcs_patch_preview", |c| async move {
vcs_patch_preview(&c.host, &c.window, c.arg("repo")?, c.arg("patch")?).await
});
+7 -28
Переглянути файл
@@ -112,11 +112,6 @@ pub trait PluginWorkspace: Send + Sync {
) -> Result<serde_json::Value, HostError> {
Err(HostError::NotFound(format!("no language server `{server}` is running for this project")))
}
/// What the IDE has resolved of the Maven / Gradle builds of the project at `root`;
/// never runs a build tool.
fn build_graph(&self, _root: &Path) -> Result<super::BuildGraph, HostError> {
Ok(super::BuildGraph::default())
}
/// Current index of the project rooted at `root`; never reads disk or calls LSP.
fn symbols(
&self,
@@ -1556,8 +1551,13 @@ impl HostApi for PluginApi {
}
Ok(())
}
fn open_diff(&self, client: &str, diff: ide_plugin::FileDiff, file_name: Option<String>) -> Result<(), HostError> {
super::execution::validate_file_diff(&diff)?;
fn open_diff(
&self,
client: &str,
diff: ide_plugin::ContentDiff,
file_name: Option<String>,
) -> Result<(), HostError> {
super::execution::validate_diff(&diff)?;
if let Some(name) = &file_name {
super::execution::label(name, 256)?;
}
@@ -2229,20 +2229,6 @@ impl HostApi for PluginApi {
Ok(result.to_string())
}
fn build_dependencies(
&self,
root: &Path,
module: Option<&str>,
) -> Result<Vec<ide_plugin::DependencyNode>, HostError> {
self.require_api("`build`", 10)?;
let workspace = self.shared.workspace().ok_or_else(|| HostError::NotFound("no project is open".into()))?;
// The graph comes from running the project's build, as `vcs.read` does git.
if !workspace.trusted(root) {
return Err(HostError::Denied("project is not trusted".into()));
}
super::build_graph::dependency_nodes(&workspace.build_graph(root)?, module)
}
fn find_files(&self, root: &Path, glob: &str, limit: usize) -> Result<Vec<String>, HostError> {
let matcher = globset::GlobBuilder::new(glob)
.literal_separator(true)
@@ -3393,13 +3379,6 @@ impl PluginWorkspace for HostWorkspace {
})
}
fn build_graph(&self, root: &Path) -> Result<super::BuildGraph, HostError> {
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()))?;
crate::ops::build::analyzed_dependencies(&project, &host.config_dir, root).map_err(failed)
}
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())
-337
Переглянути файл
@@ -1,337 +0,0 @@
//! `build.dependencies`: the Dependency Analyzer's Maven / Gradle trees as the flat
//! list the plugin API passes (records can't nest), each module a root.
use ide_build::{GradleDependency, GradleReport, MavenDependency, MavenProject, Omission};
use ide_plugin::{DependencyNode, DependencyStatus, HostError};
/// Most nodes one call returns.
const MAX_NODES: usize = 100_000;
/// What the IDE has resolved of a project's builds, without running a build tool.
#[derive(Clone, Debug, Default)]
pub struct BuildGraph {
/// Maven modules with their dependencies (with the transitive ones after a sync).
pub maven: Vec<MavenProject>,
pub gradle: Vec<GradleModule>,
}
/// A Gradle project and the reports the Dependency Analyzer read for it.
#[derive(Clone, Debug, Default)]
pub struct GradleModule {
/// Gradle path (`:`, `:app`).
pub path: String,
/// One per configuration read.
pub reports: Vec<GradleReport>,
}
/// The graph of `module` (a Maven `groupId:artifactId` or a Gradle path), or of every module.
pub fn dependency_nodes(graph: &BuildGraph, module: Option<&str>) -> Result<Vec<DependencyNode>, HostError> {
let mut out = Nodes(Vec::new());
let mut found = false;
for p in graph.maven.iter().filter(|p| module.is_none_or(|m| m == p.key())) {
found = true;
let root = out.push(DependencyNode {
group: p.group_id.clone(),
artifact: p.artifact_id.clone(),
version: p.version.clone(),
scope: String::new(),
status: DependencyStatus::Resolved,
requested_version: None,
parent: None,
})?;
out.maven(&p.dependencies, root)?;
}
for g in graph.gradle.iter().filter(|g| module.is_none_or(|m| m == g.path)) {
found = true;
let root = out.push(DependencyNode {
group: String::new(),
artifact: g.path.clone(),
version: String::new(),
scope: String::new(),
status: DependencyStatus::Resolved,
requested_version: None,
parent: None,
})?;
for report in &g.reports {
out.gradle(&report.dependencies, &report.configuration, root)?;
}
}
match module {
Some(m) if !found => Err(HostError::NotFound(format!("no Maven or Gradle module `{m}` in this project"))),
_ => Ok(out.0),
}
}
struct Nodes(Vec<DependencyNode>);
impl Nodes {
fn push(&mut self, node: DependencyNode) -> Result<u32, HostError> {
if self.0.len() >= MAX_NODES {
return Err(HostError::Failed(format!(
"the dependency graph has more than {MAX_NODES} nodes; ask for one module"
)));
}
self.0.push(node);
Ok((self.0.len() - 1) as u32)
}
fn maven(&mut self, deps: &[MavenDependency], parent: u32) -> Result<(), HostError> {
for d in deps {
let version = d.version.clone().unwrap_or_default();
let (status, version, requested) = match d.omitted {
// `version` lost to `conflict_with`.
Some(Omission::Conflict) => (
DependencyStatus::OmittedForConflict,
d.conflict_with.clone().unwrap_or_else(|| version.clone()),
Some(version),
),
Some(Omission::Duplicate | Omission::Cycle) => {
(DependencyStatus::OmittedForDuplicate, version, d.managed_from.clone())
}
None if d.managed_from.is_some() => (DependencyStatus::VersionManaged, version, d.managed_from.clone()),
None => (DependencyStatus::Resolved, version, None),
};
let index = self.push(DependencyNode {
group: d.group_id.clone(),
artifact: d.artifact_id.clone(),
requested_version: requested.filter(|r| *r != version),
version,
scope: d.scope.clone(),
status,
parent: Some(parent),
})?;
self.maven(&d.children, index)?;
}
Ok(())
}
fn gradle(&mut self, deps: &[GradleDependency], configuration: &str, parent: u32) -> Result<(), HostError> {
// A constraint is not a dependency: it occurs as one elsewhere in the tree.
for d in deps.iter().filter(|d| !d.constraint) {
let (status, version, requested) = if d.project || d.unresolved {
(DependencyStatus::Resolved, String::new(), None)
} else {
match (&d.requested, &d.selected) {
(_, None) => (DependencyStatus::Resolved, d.requested.clone().unwrap_or_default(), None),
// A platform or a constraint supplies the version.
(None, Some(selected)) => (DependencyStatus::VersionManaged, selected.clone(), None),
// Conflict resolution picked another version than this exact request.
(Some(requested), Some(selected)) if exact_version(requested) => {
(DependencyStatus::OmittedForConflict, selected.clone(), Some(requested.clone()))
}
// A range or a rich version (`1.+`, `{strictly 2.0}`) resolved as asked.
(Some(requested), Some(selected)) => {
(DependencyStatus::Resolved, selected.clone(), Some(requested.clone()))
}
}
};
let status = if d.repeated && status == DependencyStatus::Resolved {
DependencyStatus::OmittedForDuplicate
} else {
status
};
let index = self.push(DependencyNode {
group: d.group.clone(),
artifact: d.name.clone(),
requested_version: requested.filter(|r| *r != version),
version,
scope: configuration.to_owned(),
status,
parent: Some(parent),
})?;
self.gradle(&d.children, configuration, index)?;
}
Ok(())
}
}
/// `1.2.3`, not a range, dynamic or rich version (`[1,2)`, `1.+`, `latest.release`, `{strictly 1}`).
fn exact_version(v: &str) -> bool {
!v.is_empty() && !v.starts_with("latest.") && !v.contains(['[', ']', '(', ')', ',', '+', '{', '}', ' '])
}
#[cfg(test)]
mod tests {
use super::*;
fn maven(group: &str, artifact: &str, version: &str, scope: &str) -> MavenDependency {
MavenDependency {
group_id: group.into(),
artifact_id: artifact.into(),
version: Some(version.into()),
kind: "jar".into(),
scope: scope.into(),
..Default::default()
}
}
fn gradle(group: &str, name: &str, requested: Option<&str>, selected: Option<&str>) -> GradleDependency {
GradleDependency {
group: group.into(),
name: name.into(),
requested: requested.map(Into::into),
selected: selected.map(Into::into),
..Default::default()
}
}
/// (group, artifact, version, scope, status, requested, parent) of every node.
type Row<'a> = (&'a str, &'a str, &'a str, &'a str, DependencyStatus, Option<&'a str>, Option<u32>);
fn rows(nodes: &[DependencyNode]) -> Vec<Row<'_>> {
nodes
.iter()
.map(|n| {
(
n.group.as_str(),
n.artifact.as_str(),
n.version.as_str(),
n.scope.as_str(),
n.status,
n.requested_version.as_deref(),
n.parent,
)
})
.collect()
}
fn graph() -> BuildGraph {
let mut lang3_lost = maven("org.apache.commons", "commons-lang3", "3.12.0", "compile");
lang3_lost.omitted = Some(Omission::Conflict);
lang3_lost.conflict_with = Some("3.14.0".into());
let mut text = maven("org.apache.commons", "commons-text", "1.11.0", "compile");
text.children = vec![lang3_lost];
let mut logging = maven("commons-logging", "commons-logging", "1.3.0", "compile");
logging.managed_from = Some("1.2".into());
let mut junit_again = maven("junit", "junit", "4.13.2", "test");
junit_again.omitted = Some(Omission::Duplicate);
let mut hamcrest = maven("org.hamcrest", "hamcrest", "2.2", "test");
hamcrest.children = vec![junit_again];
let app = MavenProject {
group_id: "com.example".into(),
artifact_id: "app".into(),
version: "1.0".into(),
dependencies: vec![
maven("org.apache.commons", "commons-lang3", "3.14.0", "compile"),
text,
logging,
hamcrest,
],
..Default::default()
};
let mut databind = gradle("com.fasterxml.jackson.core", "jackson-databind", Some("2.15.0"), Some("2.15.3"));
databind.repeated = true;
let mut web = gradle("org.springframework.boot", "spring-boot-starter-web", None, Some("3.2.0"));
web.children = vec![databind];
let mut constraint = gradle("com.google.guava", "guava", Some("32.1.3-jre"), None);
constraint.constraint = true;
let mut core = gradle("", ":core", None, None);
core.project = true;
core.children = vec![constraint];
let mut failed = gradle("org.missing", "gone", Some("9"), None);
failed.unresolved = true;
let report = GradleReport {
project: ":web".into(),
configuration: "runtimeClasspath".into(),
dependencies: vec![
web,
core,
gradle("org.slf4j", "slf4j-api", Some("2.+"), Some("2.0.13")),
gradle("org.yaml", "snakeyaml", Some("2.2"), None),
failed,
],
};
BuildGraph {
maven: vec![app],
gradle: vec![
GradleModule { path: ":web".into(), reports: vec![report] },
GradleModule { path: ":".into(), reports: Vec::new() },
],
}
}
#[test]
fn modules_are_roots_with_their_trees_flattened_under_them() {
use DependencyStatus::*;
let nodes = dependency_nodes(&graph(), None).unwrap();
assert_eq!(
rows(&nodes),
[
("com.example", "app", "1.0", "", Resolved, None, None),
("org.apache.commons", "commons-lang3", "3.14.0", "compile", Resolved, None, Some(0)),
("org.apache.commons", "commons-text", "1.11.0", "compile", Resolved, None, Some(0)),
(
"org.apache.commons",
"commons-lang3",
"3.14.0",
"compile",
OmittedForConflict,
Some("3.12.0"),
Some(2)
),
("commons-logging", "commons-logging", "1.3.0", "compile", VersionManaged, Some("1.2"), Some(0)),
("org.hamcrest", "hamcrest", "2.2", "test", Resolved, None, Some(0)),
("junit", "junit", "4.13.2", "test", OmittedForDuplicate, None, Some(5)),
("", ":web", "", "", Resolved, None, None),
(
"org.springframework.boot",
"spring-boot-starter-web",
"3.2.0",
"runtimeClasspath",
VersionManaged,
None,
Some(7)
),
(
"com.fasterxml.jackson.core",
"jackson-databind",
"2.15.3",
"runtimeClasspath",
OmittedForConflict,
Some("2.15.0"),
Some(8)
),
("", ":core", "", "runtimeClasspath", Resolved, None, Some(7)),
("org.slf4j", "slf4j-api", "2.0.13", "runtimeClasspath", Resolved, Some("2.+"), Some(7)),
("org.yaml", "snakeyaml", "2.2", "runtimeClasspath", Resolved, None, Some(7)),
("org.missing", "gone", "", "runtimeClasspath", Resolved, None, Some(7)),
("", ":", "", "", Resolved, None, None),
]
);
}
#[test]
fn one_module_by_its_maven_key_or_gradle_path() {
let maven = dependency_nodes(&graph(), Some("com.example:app")).unwrap();
assert_eq!((maven.len(), maven[0].artifact.as_str()), (7, "app"));
let gradle = dependency_nodes(&graph(), Some(":web")).unwrap();
assert_eq!((gradle.len(), gradle[0].artifact.as_str(), gradle[1].parent), (7, ":web", Some(0)));
// A Gradle project with no report read yet is known, with nothing under it.
assert_eq!(dependency_nodes(&graph(), Some(":")).unwrap().len(), 1);
let err = dependency_nodes(&graph(), Some("app")).unwrap_err();
assert!(matches!(err, HostError::NotFound(_)), "{err:?}");
assert!(dependency_nodes(&BuildGraph::default(), None).unwrap().is_empty());
}
#[test]
fn a_graph_too_large_for_one_call_fails() {
let app = MavenProject {
group_id: "g".into(),
artifact_id: "a".into(),
dependencies: vec![maven("g", "d", "1", "compile"); MAX_NODES],
..Default::default()
};
let graph = BuildGraph { maven: vec![app], gradle: Vec::new() };
assert!(matches!(dependency_nodes(&graph, None), Err(HostError::Failed(_))));
}
#[test]
fn exact_versions() {
for v in ["1.0", "32.1.3-jre", "2.15.0"] {
assert!(exact_version(v), "{v}");
}
for v in ["", "1.+", "[1.0,2.0)", "latest.release", "{strictly 1.0}"] {
assert!(!exact_version(v), "{v}");
}
}
}
+4 -45
Переглянути файл
@@ -91,31 +91,12 @@ fn diff_side(value: &str, side: &str) -> Result<(), HostError> {
}
pub(super) fn validate_diff(diff: &ide_plugin::ContentDiff) -> Result<(), HostError> {
validate_diff_parts([Some(&diff.left), Some(&diff.right)], [&diff.left_label, &diff.right_label], &diff.title)
}
/// A `None` side doesn't exist (an added or deleted file); at least one side does.
pub(super) fn validate_file_diff(diff: &ide_plugin::FileDiff) -> Result<(), HostError> {
validate_diff_parts([diff.left.as_ref(), diff.right.as_ref()], [&diff.left_label, &diff.right_label], &diff.title)
}
fn validate_diff_parts(
sides: [Option<&String>; 2],
labels: [&Option<String>; 2],
title: &Option<String>,
) -> Result<(), HostError> {
if sides.iter().all(Option::is_none) {
return Err(HostError::Invalid("a diff needs at least one side".into()));
}
for (value, side) in sides.into_iter().zip(["left", "right"]) {
if let Some(value) = value {
diff_side(value, side)?;
}
}
for value in labels.into_iter().flatten() {
diff_side(&diff.left, "left")?;
diff_side(&diff.right, "right")?;
for value in [&diff.left_label, &diff.right_label].into_iter().flatten() {
label(value, 128)?;
}
if let Some(title) = title {
if let Some(title) = &diff.title {
label(title, 256)?;
}
Ok(())
@@ -732,28 +713,6 @@ mod tests {
);
}
#[test]
fn a_file_diff_may_miss_one_side_but_not_both() {
let side = |left: Option<&str>, right: Option<&str>| ide_plugin::FileDiff {
left: left.map(Into::into),
right: right.map(Into::into),
..Default::default()
};
assert!(validate_file_diff(&side(None, Some("added\n"))).is_ok());
assert!(validate_file_diff(&side(Some("deleted\n"), None)).is_ok());
assert!(validate_file_diff(&side(Some(""), Some(""))).is_ok());
assert!(
matches!(validate_file_diff(&side(None, None)), Err(HostError::Invalid(m)) if m == "a diff needs at least one side")
);
let huge = "y".repeat(MAX_DIFF_SIDE + 1);
assert!(
matches!(validate_file_diff(&side(None, Some(&huge))), Err(HostError::Invalid(m)) if m == "diff too large: the right side is over 8 MiB")
);
assert!(
matches!(validate_file_diff(&side(Some("a\0"), None)), Err(HostError::Invalid(m)) if m.contains("NUL"))
);
}
fn launch(
env: Vec<(&str, &str)>,
debugger: Option<ide_plugin::PluginDebugger>,
-250
Переглянути файл
@@ -1,250 +0,0 @@
//! The `javaAgents` extension point (API 1.10): a Java agent the host loads into the
//! JVM of Application, Spring Boot and JAR Application configurations.
//!
//! ```toml
//! [[contributes.javaAgents]]
//! path = "agent/openidea-spring-agent.jar" # inside the package
//! args = "optional-arguments" # optional
//! ```
//!
//! One agent per plugin. The declaration derives the optional high-risk `java.agent`
//! capability; granting it records the jar's hash, and a launch adds the agent only
//! while the jar still has it ([`ide_run::java_agent`]).
use ide_extension::{Capability, Disposable, ExtensionPoint, Manifest, Package, Placement, Prepared, decode};
use ide_language::ProgramPin;
use ide_run::java_agent::{ContributedAgent, JavaAgentSource};
use parking_lot::RwLock;
use serde::Deserialize;
use std::collections::HashMap;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use std::sync::atomic::{AtomicU64, Ordering};
pub const POINT_ID: &str = "javaAgents";
const MAX_ARGS: usize = 4096;
#[derive(Clone, Debug, Deserialize)]
#[serde(deny_unknown_fields)]
struct Decl {
path: PathBuf,
#[serde(default)]
args: Option<String>,
}
#[derive(Clone, Debug)]
struct Agent {
/// The jar, resolved inside the package.
jar: PathBuf,
args: Option<String>,
}
/// Agents of enabled plugins.
#[derive(Default)]
pub struct JavaAgents {
items: RwLock<Vec<(u64, String, Agent)>>,
seq: AtomicU64,
}
impl JavaAgents {
fn add(self: &Arc<Self>, plugin: String, agent: Agent) -> Disposable {
let seq = self.seq.fetch_add(1, Ordering::Relaxed);
self.items.write().push((seq, plugin, agent));
let weak = Arc::downgrade(self);
Disposable::new(move || {
if let Some(this) = weak.upgrade() {
this.items.write().retain(|(s, _, _)| *s != seq);
}
})
}
}
pub struct JavaAgentsPoint {
store: Arc<JavaAgents>,
}
impl JavaAgentsPoint {
pub fn new(store: Arc<JavaAgents>) -> Self {
Self { store }
}
}
impl ExtensionPoint for JavaAgentsPoint {
fn id(&self) -> &'static str {
POINT_ID
}
fn placement(&self) -> Placement {
Placement::Workspace
}
fn prepare(&self, pkg: &Package, decl: toml::Value) -> Result<Prepared, String> {
pkg.manifest.needs_api("contributes.javaAgents", 10)?;
if pkg.manifest.declarations(POINT_ID).len() > 1 {
return Err("contributes.javaAgents: a plugin contributes at most one Java agent".into());
}
let d: Decl = decode(POINT_ID, decl)?;
let jar = resolve(&pkg.dir, &d.path)?;
let args = d.args.filter(|a| !a.is_empty());
if let Some(args) = &args
&& (args.len() > MAX_ARGS || args.contains(|c: char| c.is_control()))
{
return Err(format!("contributes.javaAgents: `args` must be one line of at most {MAX_ARGS} bytes"));
}
let label = label(&d.path, args.as_deref());
let (store, plugin) = (self.store.clone(), pkg.id().to_owned());
let agent = Agent { jar, args };
Ok(Prepared::new(label, move || Ok(store.add(plugin, agent))).file(d.path).capability(Capability::JavaAgent))
}
}
/// What Settings › Plugins shows: the jar's file name and its arguments, as `-javaagent:` takes them.
fn label(path: &Path, args: Option<&str>) -> String {
let name = path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
match args {
Some(args) => format!("{name}={args}"),
None => name,
}
}
/// The jar a package's declaration names, as an absolute path inside the package:
/// `..`, absolute paths and symlinks that lead out of it are refused.
fn resolve(dir: &Path, rel: &Path) -> Result<PathBuf, String> {
ide_extension::check_relative(rel, "contributes.javaAgents: `path`")?;
let root = dunce::canonicalize(dir).map_err(|e| format!("plugin directory: {e}"))?;
let jar = dunce::canonicalize(dir.join(rel))
.map_err(|_| format!("contributes.javaAgents: {}: no such file in the plugin", rel.display()))?;
if !jar.starts_with(&root) {
return Err(format!("contributes.javaAgents: {}: points outside the plugin", rel.display()));
}
if !jar.is_file() {
return Err(format!("contributes.javaAgents: {}: not a file", rel.display()));
}
Ok(jar)
}
/// The jar the package at `dir` declares, for recording its hash when `java.agent`
/// is granted (before the declaration has taken effect, as on install).
pub(super) fn declared_jar(manifest: &Manifest, dir: &Path) -> Option<PathBuf> {
let decl = manifest.declarations(POINT_ID).into_iter().next()?;
let d: Decl = decode(POINT_ID, decl).ok()?;
resolve(dir, &d.path).ok()
}
type Pins = Arc<RwLock<HashMap<(String, String), ProgramPin>>>;
/// [`JavaAgentSource`] over the agents and the hashes granted for them.
pub struct PluginJavaAgents {
pub(super) store: Arc<JavaAgents>,
pub(super) pins: Pins,
}
impl JavaAgentSource for PluginJavaAgents {
fn agents(&self) -> Vec<ContributedAgent> {
let cap = Capability::JavaAgent.to_string();
let pins = self.pins.read();
self.store
.items
.read()
.iter()
.map(|(_, plugin, agent)| ContributedAgent {
plugin: plugin.clone(),
jar: agent.jar.clone(),
args: agent.args.clone(),
approved_hash: pins.get(&(plugin.clone(), cap.clone())).map(|pin| pin.hash.clone()),
})
.collect()
}
}
#[cfg(test)]
mod tests {
use super::*;
const MANIFEST: &str =
"id = \"acme.spring\"\nname = \"Spring\"\nversion = \"1.0.0\"\nengines.openidea = \"^1.10\"\n";
fn package(dir: &Path, manifest: &str) -> Package {
std::fs::create_dir_all(dir.join("agent")).unwrap();
std::fs::write(dir.join("agent/spring agent.jar"), b"PK").unwrap();
Package::new(Manifest::parse(manifest).unwrap(), dir.to_path_buf())
}
fn prepare(pkg: &Package) -> Result<Prepared, String> {
let point = JavaAgentsPoint::new(Arc::default());
let decls = pkg.manifest.declarations(POINT_ID);
let mut last = Err("no declaration".into());
for decl in decls {
last = Ok(point.prepare(pkg, decl)?);
}
last
}
#[test]
fn parses_the_declaration_and_derives_the_capability() {
let tmp = tempfile::tempdir().unwrap();
let toml = format!(
"{MANIFEST}[[contributes.javaAgents]]\npath = \"agent/spring agent.jar\"\nargs = \"port=0,trace\"\n"
);
let pkg = package(tmp.path(), &toml);
let prepared = prepare(&pkg).unwrap();
assert_eq!(prepared.capabilities, [Capability::JavaAgent]);
assert_eq!(prepared.files, [PathBuf::from("agent/spring agent.jar")]);
assert_eq!(prepared.label, "spring agent.jar=port=0,trace");
let jar = declared_jar(&pkg.manifest, &pkg.dir).unwrap();
assert_eq!(jar, dunce::canonicalize(tmp.path().join("agent/spring agent.jar")).unwrap());
let store: Arc<JavaAgents> = Arc::default();
let point = JavaAgentsPoint::new(store.clone());
let decl = pkg.manifest.declarations(POINT_ID).remove(0);
let disposable = (point.prepare(&pkg, decl).unwrap().commit)().unwrap();
let source = PluginJavaAgents { store: store.clone(), pins: Arc::default() };
let agents = source.agents();
assert_eq!(agents.len(), 1);
assert_eq!(
(agents[0].plugin.as_str(), agents[0].args.as_deref(), agents[0].approved_hash.as_ref()),
("acme.spring", Some("port=0,trace"), None)
);
source.pins.write().insert(("acme.spring".into(), "java.agent".into()), ProgramPin::approve(&jar).unwrap());
assert!(source.agents()[0].approved_hash.is_some());
disposable.dispose();
assert!(source.agents().is_empty(), "disabling the plugin drops its agent");
}
#[test]
fn refuses_what_would_fail_at_launch() {
let tmp = tempfile::tempdir().unwrap();
let outside = tempfile::tempdir().unwrap();
std::fs::write(outside.path().join("evil.jar"), b"PK").unwrap();
let refused = |n: usize, manifest: &str| {
let dir = tmp.path().join(n.to_string());
prepare(&package(&dir, manifest)).map(|_| ()).unwrap_err()
};
let case = |n: usize, body: &str| refused(n, &format!("{MANIFEST}{body}"));
let agent = |path: &str| format!("[[contributes.javaAgents]]\npath = \"{path}\"\n");
assert!(case(0, &agent("../evil.jar")).contains("relative path inside the plugin"));
assert!(case(1, &agent("/etc/passwd")).contains("relative path inside the plugin"));
assert!(case(2, &agent("agent/missing.jar")).contains("no such file"));
assert!(case(3, &agent("agent")).contains("not a file"));
let two = format!("{}{}", agent("agent/spring agent.jar"), agent("agent/spring agent.jar"));
assert!(case(4, &two).contains("at most one Java agent"));
assert!(
case(5, "[[contributes.javaAgents]]\npath = \"agent/spring agent.jar\"\nargs = \"a\\nb\"\n")
.contains("one line")
);
assert!(
case(6, "[[contributes.javaAgents]]\npath = \"agent/spring agent.jar\"\nmain = \"x\"\n")
.contains("unknown field")
);
let old = format!("{}{}", MANIFEST.replace("^1.10", "^1.9"), agent("agent/spring agent.jar"));
assert!(refused(7, &old).contains("new in plugin API 1.10"));
#[cfg(unix)]
{
let dir = tmp.path().join("8");
let pkg = package(&dir, &format!("{MANIFEST}{}", agent("agent/link.jar")));
std::os::unix::fs::symlink(outside.path().join("evil.jar"), dir.join("agent/link.jar")).unwrap();
assert!(prepare(&pkg).map(|_| ()).unwrap_err().contains("points outside the plugin"));
assert_eq!(declared_jar(&pkg.manifest, &pkg.dir), None);
}
}
}
+5 -34
Переглянути файл
@@ -17,7 +17,6 @@
mod api;
mod auth;
mod build_graph;
pub mod commands;
pub mod commit;
mod database;
@@ -38,7 +37,6 @@ mod inlay_hints;
mod install;
pub mod intellij;
mod ipc;
mod java_agents;
pub mod language_features;
mod market;
mod mcp;
@@ -60,7 +58,6 @@ pub mod web;
mod websocket;
pub use api::{FileSecretStore, HostWorkspace, PluginWorkspace, SecretStore};
pub use build_graph::{BuildGraph, GradleModule};
pub(crate) use hover::merge as merge_hover;
pub use icons::{
MAX_PLUGIN_ICON, map_asset as icon_theme_map_asset, plugin_icon, sanitize_svg, svg_prefix as icon_theme_svg_prefix,
@@ -381,8 +378,6 @@ pub struct PluginHost {
ui: Arc<UiStore>,
languages: Arc<PluginLanguages>,
run_detectors: Arc<run_detectors::RunDetectors>,
/// `[[contributes.javaAgents]]` of enabled plugins.
java_agents: Arc<java_agents::JavaAgents>,
/// `[[contributes.providers]]` of enabled plugins.
providers: Arc<providers::Providers>,
navigation: Mutex<navigation::NavigationIndex>,
@@ -462,9 +457,7 @@ impl PluginHost {
let languages = PluginLanguages::new();
let run_detectors: Arc<run_detectors::RunDetectors> = Arc::default();
let providers: Arc<providers::Providers> = Arc::default();
let java_agents: Arc<java_agents::JavaAgents> = Arc::default();
register_builtin_points(&registry, &ui, &languages, &run_detectors, &java_agents, &providers)
.map_err(IdeError::internal)?;
register_builtin_points(&registry, &ui, &languages, &run_detectors, &providers).map_err(IdeError::internal)?;
let pins: Arc<RwLock<HashMap<(String, String), ProgramPin>>> = Arc::default();
let policy_pins = pins.clone();
languages.set_process_policy(Arc::new(move |plugin, cap| {
@@ -498,7 +491,6 @@ impl PluginHost {
ui,
languages,
run_detectors,
java_agents,
providers,
navigation: Mutex::default(),
endpoints: Mutex::default(),
@@ -999,8 +991,8 @@ impl PluginHost {
};
// Consent covers what the install page showed.
let request = request_for(&subject, &pkg.manifest, &hash, &set.capabilities);
self.record_consent(&request, consent);
let dir = install::active_dir(&root).ok_or_else(|| IdeError::internal("the installed version is missing"))?;
self.record_consent(&request, consent, agent_jar_grant(&pkg.manifest, &dir));
self.load_dir(&dir, PluginSource::Installed, None);
if let Some(previous) = previous {
let failed = self
@@ -1118,7 +1110,7 @@ impl PluginHost {
let hash = self.package_hash_of(&plugin);
let extra = plugin.meta.lock().declared_extra.clone();
let request = request_for(&plugin.subject(), plugin.manifest(), &hash, &extra);
self.record_consent(&request, consent, agent_jar_grant(plugin.manifest(), plugin.dir()));
self.record_consent(&request, consent);
self.stop(&plugin);
if !self.state.lock().disabled.contains(id) {
self.start(&plugin);
@@ -1168,12 +1160,6 @@ impl PluginHost {
return Err(IdeError::invalid(format!("plugin {id:?} has not been confirmed yet")));
}
ledger.set(&subject, &cap, granted);
if granted
&& cap == Capability::JavaAgent
&& let Some(jar) = agent_jar_grant(plugin.manifest(), plugin.dir())
{
ledger.set_binary(&subject, &cap, jar);
}
if granted
&& let Capability::Process(program) = &cap
&& let Some(bin) = ledger
@@ -1710,11 +1696,6 @@ impl PluginHost {
})
}
/// Plugins' `javaAgents`, for [`ide_run::java_agent::set_java_agent_source`].
pub fn java_agents(&self) -> Arc<dyn ide_run::java_agent::JavaAgentSource> {
Arc::new(java_agents::PluginJavaAgents { store: self.java_agents.clone(), pins: self.pins.clone() })
}
/// The syntax of plugin languages, for [`ide_language::set_external_syntax`].
pub fn syntax_provider(self: &Arc<Self>) -> Arc<dyn ide_language::ExternalSyntax> {
Arc::new(PluginSyntax(Arc::downgrade(self)))
@@ -2952,7 +2933,7 @@ impl PluginHost {
}
let declared =
plugin.manifest().capabilities.all().cloned().chain(plugin.meta.lock().declared_extra.clone());
for cap in declared.filter(|c| matches!(c, Capability::Process(_) | Capability::JavaAgent)) {
for cap in declared.filter(|c| matches!(c, Capability::Process(_))) {
if let Some(bin) = ledger.pinned_binary(&subject, &cap) {
pins.insert(
(plugin.id().to_owned(), cap.to_string()),
@@ -3013,9 +2994,7 @@ impl PluginHost {
self.save_ledger(&ledger);
}
/// `agent_jar`: the jar of the plugin's `javaAgents` declaration, recorded when
/// `java.agent` is accepted.
fn record_consent(&self, request: &Request<'_>, consent: &Consent, agent_jar: Option<BinaryGrant>) {
fn record_consent(&self, request: &Request<'_>, consent: &Consent) {
let accepted: Vec<Capability> = request.optional.iter().filter(|c| consent.accepts(c)).cloned().collect();
let choices: BTreeMap<_, _> = {
let ledger = self.ledger.lock();
@@ -3037,7 +3016,6 @@ impl PluginHost {
.get(&c.to_string())
.map_or_else(|| self.resolve_binary(program), |path| ledger::approve_program(path).ok())
.map(|b| (c.to_string(), b)),
Capability::JavaAgent => agent_jar.clone().map(|jar| (c.to_string(), jar)),
_ => None,
})
.collect();
@@ -3116,13 +3094,6 @@ impl Drop for PluginHost {
}
}
/// The jar of a package's `javaAgents` declaration with its hash now, for a `java.agent` grant.
fn agent_jar_grant(manifest: &Manifest, dir: &Path) -> Option<BinaryGrant> {
let path = java_agents::declared_jar(manifest, dir)?;
let hash = ledger::file_hash(&path).map_err(|e| tracing::info!("java.agent: {}: {e}", path.display())).ok()?;
Some(BinaryGrant { path, hash })
}
fn request_for<'a>(subject: &Subject, m: &'a Manifest, hash: &'a str, declared: &[Capability]) -> Request<'a> {
let mut optional = m.capabilities.optional.clone();
// What declarations need (a language server's `process:`) is optional:
-2
Переглянути файл
@@ -64,7 +64,6 @@ pub fn register_builtin_points(
ui: &Arc<UiStore>,
languages: &Arc<PluginLanguages>,
run_detectors: &Arc<super::run_detectors::RunDetectors>,
java_agents: &Arc<super::java_agents::JavaAgents>,
providers: &Arc<super::providers::Providers>,
) -> Result<(), String> {
registry.register(Arc::new(UiPoint::new(COMMANDS, ui.clone(), command)))?;
@@ -72,7 +71,6 @@ pub fn register_builtin_points(
registry.register(Arc::new(LanguagesPoint::new(languages.clone())))?;
registry.register(Arc::new(UiPoint::new(super::icons::POINT_ID, ui.clone(), super::icons::icon_theme)))?;
registry.register(Arc::new(super::run_detectors::RunDetectorsPoint::new(run_detectors.clone())))?;
registry.register(Arc::new(super::java_agents::JavaAgentsPoint::new(java_agents.clone())))?;
registry.register(Arc::new(super::navigation::IndexersPoint))?;
registry.register(Arc::new(super::providers::ProvidersPoint::new(providers.clone())))?;
registry.register(Arc::new(UiPoint::new(super::providers::SECRETS_POINT, ui.clone(), super::providers::secret)))?;
+1 -1
Переглянути файл
@@ -220,7 +220,7 @@ pub enum PluginEvent {
ContentTabReply { plugin_id: String, request_id: String, reply: ide_plugin::ContentTabReply },
/// Open two texts in this window's diff viewer.
#[serde(rename_all = "camelCase")]
OpenDiff { plugin_id: String, diff: ide_plugin::FileDiff, file_name: Option<String> },
OpenDiff { plugin_id: String, diff: ide_plugin::ContentDiff, file_name: Option<String> },
/// Plugins, their status or their contributions changed: re-fetch `plugin_list`.
CommandsChanged,
+4 -57
Переглянути файл
@@ -13,7 +13,6 @@
//! [[contributes.keymaps]]
//! command = "check"
//! key = "Ctrl+Alt+C" # `mac` for a different binding on macOS (`Meta+Alt+C`)
//! # key = "Escape" + when = "…" # API 1.10: Escape in an editor that the IDE had no use for
//!
//! [[contributes.statusBar]]
//! id = "branch"
@@ -204,16 +203,8 @@ struct KeymapDecl {
key: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
mac: Option<String>,
/// Only with an `Escape` binding (API 1.10): when the command clears something.
#[serde(default, skip_serializing_if = "Option::is_none")]
when: Option<String>,
}
/// The one plain key a plugin may bind (API 1.10): in a focused editor, after the IDE's own uses of
/// Escape (popups, completion, rename, selection, extra carets, Vim) found nothing to do, like a
/// handler at the end of IDEA's EditorEscape chain.
const ESCAPE: &str = "Escape";
const MODIFIERS: [&str; 4] = ["Meta", "Ctrl", "Alt", "Shift"];
const NAMED_KEYS: [&str; 22] = [
"Enter",
@@ -271,21 +262,9 @@ pub fn validate_binding(binding: &str) -> Result<(), String> {
pub(super) fn keymap(pkg: &Package, decl: toml::Value) -> Result<UiDecl, String> {
let d: KeymapDecl = decode(KEYMAPS, decl)?;
declared_command(pkg, KEYMAPS, &d.command)?;
let escape = d.key == ESCAPE || d.mac.as_deref() == Some(ESCAPE);
if escape {
if d.key != ESCAPE || d.mac.as_deref().is_some_and(|m| m != ESCAPE) {
return Err("contributes.keymaps: an Escape binding is Escape on every platform".into());
}
pkg.manifest.needs_api("contributes.keymaps key = \"Escape\"", 10)?;
let when = d.when.as_deref().ok_or("contributes.keymaps: an Escape binding needs a `when` clause")?;
validate_when(when).map_err(|e| format!("contributes.keymaps: {e}"))?;
} else if d.when.is_some() {
return Err("contributes.keymaps: `when` is only for an Escape binding".into());
}
for binding in std::iter::once(&d.key).chain(&d.mac) {
if binding != ESCAPE {
validate_binding(binding).map_err(|e| format!("contributes.keymaps: {e}"))?;
}
validate_binding(&d.key).map_err(|e| format!("contributes.keymaps: {e}"))?;
if let Some(m) = &d.mac {
validate_binding(m).map_err(|e| format!("contributes.keymaps: {e}"))?;
}
Ok(UiDecl::new(d.command.clone(), d.key.clone(), json(&d)?))
}
@@ -1135,37 +1114,6 @@ mod tests {
}
}
#[test]
fn escape_bindings_need_api_1_10_and_a_when_clause() {
let pkg = |api: &str| {
let manifest = ide_extension::Manifest::parse(&format!(
"id='test'\nname='Test'\nversion='1.0.0'\nengines.openidea='{api}'\n[[contributes.commands]]\nid='clear'\ntitle='Clear'"
))
.unwrap();
Package::new(manifest, std::path::PathBuf::from("/unused"))
};
let check = |api: &str, decl: &str| keymap(&pkg(api), toml::from_str(decl).unwrap());
let escape = "command='clear'\nkey='Escape'\nwhen='plugin.test.active'";
let ok = check("^1.10", escape).unwrap();
assert_eq!(ok.json["when"], "plugin.test.active");
assert!(check("^1.10", &format!("{escape}\nmac='Escape'")).is_ok());
for (api, decl, error) in [
("^1.9", escape, "1.10"),
("^1.10", "command='clear'\nkey='Escape'", "when"),
("^1.10", "command='clear'\nkey='Escape'\nwhen='a &&'", "when"),
("^1.10", &format!("{escape}\nmac='Meta+K'") as &str, "every platform"),
("^1.10", "command='clear'\nkey='Ctrl+K'\nmac='Escape'\nwhen='x'", "every platform"),
("^1.10", "command='clear'\nkey='Ctrl+K'\nwhen='x'", "only for an Escape"),
("^1.10", "command='clear'\nkey='Enter'", "needs Ctrl"),
("^1.10", "command='clear'\nkey='Shift+Escape'", "needs Ctrl"),
] {
let err = check(api, decl).unwrap_err();
assert!(err.contains(error), "{api} {decl}\n→ {err}");
}
// Other bindings are unchanged.
assert!(check("^1.9", "command='clear'\nkey='Ctrl+Alt+C'").is_ok());
}
#[test]
fn bindings_need_a_modifier() {
for ok in ["Ctrl+Alt+C", "Meta+Shift+K", "F5", "Shift+F6", "Meta+K Meta+C", "Alt+Enter"] {
@@ -1295,8 +1243,7 @@ mod tests {
#[test]
fn editor_panels_validate_api_width_when_capability_and_page() {
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("../ide-plugin/tests/fixtures/editor-panel");
// A Windows checkout may have CRLF line ends; the edits below match on `\n`.
let source = std::fs::read_to_string(root.join("plugin.toml")).unwrap().replace("\r\n", "\n");
let source = std::fs::read_to_string(root.join("plugin.toml")).unwrap();
let check = |source: &str| {
let manifest = ide_extension::Manifest::parse(source)?;
let decl = manifest.declarations(EDITOR_PANELS).into_iter().next().unwrap();
+23 -58
Переглянути файл
@@ -112,7 +112,7 @@ impl Host {
let detected_roots = Arc::new(RwLock::new(ide_workspace::roots::detect(&root)));
let excludes = exclude_globs(&root, &settings.effective(), &detected_roots.read());
let build_cache = self.local_data_dir.join("cache").join(project_key(&root)).join("build");
let extra_roots = content_roots(&settings.effective(), &root, &build_cache, trusted.load(Ordering::Acquire));
let extra_roots = content_roots(&settings.effective(), &root, &build_cache);
mark("roots");
// The project's own registry: File Types associations may be project-scoped.
@@ -147,9 +147,7 @@ impl Host {
lsp.set_content_roots(language_server_roots(&root, extra_roots.clone()));
lsp.set_jdtls_import_roots(ide_build::maven_external_roots(
&root,
&build_cache,
&settings.effective().languages.java.maven,
trusted.load(Ordering::Acquire),
&settings.effective().languages.java.maven.linked_projects,
));
let settings = Arc::new(settings);
{
@@ -286,7 +284,6 @@ impl Host {
lsp.set_prepare_hook(Box::new(move |cfg, _, cancel| {
let effective = settings.effective();
if cfg.name == "jdtls" {
ide_sdk::jdtls_workspaces::mark_used(cfg);
crate::java_runtime::prepare(
cfg,
&data_dir,
@@ -418,10 +415,7 @@ impl Host {
// Detected excluded folders (`target`, `build`) leave the index too.
let effective = settings.effective();
index.set_scope(
index_roots(
&root,
content_roots(&effective, &root, &build_cache, trusted.load(Ordering::Acquire)),
),
index_roots(&root, content_roots(&effective, &root, &build_cache)),
exclude_globs(&root, &effective, &fresh),
);
*detected_roots.write() = fresh;
@@ -464,14 +458,7 @@ impl Host {
// through the `.git` paths above; this covers the whole tree being brought in.
git_dirs |= batch.created.iter().any(|p| p.join(".git").exists());
if git_dirs {
scan_repositories(
&root,
&repos,
&settings,
&sink,
&build_cache,
trusted.load(Ordering::Acquire),
);
scan_repositories(&root, &repos, &settings, &sink, &build_cache);
}
let vcs_moved = batch.vcs.iter().any(|p| vcs_path_changed(p));
if git_dirs || vcs_moved {
@@ -557,10 +544,9 @@ impl Host {
{
let (root, repos, settings, sink) = (root.clone(), repos.clone(), settings.clone(), sink.clone());
let build_cache = build_cache.clone();
let trusted = trusted.load(Ordering::Acquire);
std::thread::Builder::new()
.name("openidea-vcs-roots".into())
.spawn(move || scan_repositories(&root, &repos, &settings, &sink, &build_cache, trusted))?;
.spawn(move || scan_repositories(&root, &repos, &settings, &sink, &build_cache))?;
}
mark("git");
tracing::info!("opened {} in window {window} in {} ms {laps:?}", root.display(), started.elapsed().as_millis());
@@ -921,9 +907,8 @@ fn scan_repositories(
settings: &SettingsStore,
sink: &SharedSink,
build_cache: &Path,
trusted: bool,
) {
match discover_repositories(root, settings, build_cache, trusted) {
match discover_repositories(root, settings, build_cache) {
Ok(found) => {
if found.roots() != repos.read().roots() {
*repos.write() = found;
@@ -936,7 +921,7 @@ fn scan_repositories(
/// The repository containing `root` and those nested below it or below a content root.
/// The project-open scan and the watcher's rescan share these skip rules.
fn discover_repositories(root: &Path, settings: &SettingsStore, build_cache: &Path, trusted: bool) -> IdeResult<Repos> {
fn discover_repositories(root: &Path, settings: &SettingsStore, build_cache: &Path) -> IdeResult<Repos> {
let ignored = settings.effective().ignored_names();
let skip = |p: &Path| {
p.file_name().is_some_and(|n| {
@@ -947,20 +932,13 @@ fn discover_repositories(root: &Path, settings: &SettingsStore, build_cache: &Pa
})
};
let mut roots = vec![root.to_path_buf()];
roots.extend(content_roots(&settings.effective(), root, build_cache, trusted));
roots.extend(content_roots(&settings.effective(), root, build_cache));
Repos::discover_roots(&roots, &skip)
}
impl Project {
pub fn refresh_repositories(&self) {
scan_repositories(
&self.root,
&self.repos,
&self.settings,
&self.sink,
&self.build_cache_dir(),
self.is_trusted(),
);
scan_repositories(&self.root, &self.repos, &self.settings, &self.sink, &self.build_cache_dir());
}
/// The project's git repositories.
@@ -1226,7 +1204,7 @@ impl Project {
/// Project Structure content roots besides the project folder (existing directories).
pub fn content_roots(&self) -> Vec<PathBuf> {
content_roots(&self.settings.effective(), &self.root, &self.build_cache_dir(), self.is_trusted())
content_roots(&self.settings.effective(), &self.root, &self.build_cache_dir())
}
/// Applies Settings › File Types; open documents whose language changed are
@@ -1250,9 +1228,7 @@ impl Project {
self.lsp.set_content_roots(language_server_roots(&self.root, roots.clone()));
self.lsp.set_jdtls_import_roots(ide_build::maven_external_roots(
&self.root,
&self.build_cache_dir(),
&self.settings.effective().languages.java.maven,
self.is_trusted(),
&self.settings.effective().languages.java.maven.linked_projects,
));
self.index.set_scope(index_roots(&self.root, roots.clone()), excludes.clone());
self.watcher.set_excludes(&excludes);
@@ -1378,14 +1354,8 @@ pub(crate) fn workspace_member_roots(root: &Path) -> Vec<PathBuf> {
/// Workspace members in manifest order, or the attached projects outside the project and
/// those inside it that its walk skips as ignored (a git worktree under an ignored folder),
/// extra Project Structure directories, Gradle project folders outside the project, and
/// directories of Maven POMs linked from outside it and, when `trusted`, of the Maven reactor's
/// modules there (`build_cache` holds the Gradle and Maven sync results).
fn content_roots(
settings: &ide_core::settings::Settings,
root: &Path,
build_cache: &Path,
trusted: bool,
) -> Vec<PathBuf> {
/// directories of Maven POMs linked from outside it (`build_cache` is the Gradle sync cache).
fn content_roots(settings: &ide_core::settings::Settings, root: &Path, build_cache: &Path) -> Vec<PathBuf> {
if let Ok(Some(workspace)) = ide_workspace::workspace::Workspace::load(root) {
if workspace.is_container(root) {
return workspace.projects;
@@ -1395,14 +1365,14 @@ fn content_roots(
.into_iter()
.filter(|p| !p.starts_with(root) || ide_index::walk_skips(root, p))
.collect::<Vec<_>>();
for path in extra_content_roots(settings, root, build_cache, trusted) {
for path in extra_content_roots(settings, root, build_cache) {
if !roots.contains(&path) {
roots.push(path);
}
}
return roots;
}
extra_content_roots(settings, root, build_cache, trusted)
extra_content_roots(settings, root, build_cache)
}
/// The content roots plus the projects attached inside this one. The index covers those
@@ -1469,7 +1439,7 @@ fn navigation_roots_uncached(project: &Project, from: &Path) -> Vec<PathBuf> {
}
}
if workspace.is_none() {
for root in content_roots(&settings, &project.root, &project.build_cache_dir(), project.is_trusted()) {
for root in content_roots(&settings, &project.root, &project.build_cache_dir()) {
if !roots.contains(&root) {
roots.push(root);
}
@@ -1488,12 +1458,7 @@ fn member_dependencies_for<'a>(map: &'a BTreeMap<String, Vec<String>>, own_key:
map.iter().find(|(key, _)| ide_core::ipc_path::to_ipc(&PathBuf::from(key)) == own_key).map(|(_, deps)| deps)
}
fn extra_content_roots(
settings: &ide_core::settings::Settings,
root: &Path,
build_cache: &Path,
trusted: bool,
) -> Vec<PathBuf> {
fn extra_content_roots(settings: &ide_core::settings::Settings, root: &Path, build_cache: &Path) -> Vec<PathBuf> {
let mut out: Vec<PathBuf> = Vec::new();
let user = settings
.project_structure
@@ -1503,7 +1468,7 @@ fn extra_content_roots(
.map(|r| PathBuf::from(r.trim()));
for p in user
.chain(ide_build::gradle_external_roots(root, build_cache, &settings.languages.java.gradle))
.chain(ide_build::maven_external_roots(root, build_cache, &settings.languages.java.maven, trusted))
.chain(ide_build::maven_external_roots(root, &settings.languages.java.maven.linked_projects))
{
if p.is_absolute() && p.is_dir() && !p.starts_with(root) && !out.contains(&p) {
out.push(p);
@@ -1989,11 +1954,11 @@ mod maven_linkage_tests {
}
let mut settings = ide_core::settings::Settings::default();
settings.languages.java.maven.linked_projects = vec!["../B/pom.xml".into()];
assert_eq!(super::content_roots(&settings, &a, &base.join("cache"), false), vec![b]);
assert_eq!(super::content_roots(&settings, &a, &base.join("cache")), vec![b]);
// External links must not replace jdtls's scan of the opened root with a build-file list.
assert_eq!(super::jdtls_maven_import(&a, &settings), (Vec::new(), None));
settings.languages.java.maven.linked_projects.clear();
assert!(super::content_roots(&settings, &a, &base.join("cache"), false).is_empty());
assert!(super::content_roots(&settings, &a, &base.join("cache")).is_empty());
}
#[test]
@@ -2217,7 +2182,7 @@ mod content_roots_tests {
settings.project_structure.content_roots = vec![shared.to_string_lossy().into_owned()];
settings.project_structure.dependencies =
vec![dep.to_string_lossy().into_owned(), root.to_string_lossy().into_owned()];
let roots = content_roots(&settings, &root, &tmp.path().join("build"), false);
let roots = content_roots(&settings, &root, &tmp.path().join("build"));
assert_eq!(roots, vec![shared, dep]);
}
@@ -2231,12 +2196,12 @@ mod content_roots_tests {
}
let settings = ide_core::settings::Settings::default();
let build = ws.join("build");
assert!(super::language_server_roots(&root, content_roots(&settings, &root, &build, false)).is_empty());
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, false);
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]);
+1 -9
Переглянути файл
@@ -245,18 +245,10 @@ impl crate::Host {
pub async fn refresh_project_trust(&self) -> IdeResult<()> {
for project in self.projects().into_iter().filter(|p| !p.light) {
let trusted = self.trust.window_trusted(&project.root).unwrap_or(false);
let roots = project.content_roots();
let previous = project.trusted.swap(trusted, std::sync::atomic::Ordering::AcqRel);
if previous == trusted {
continue;
}
// Maven reactor modules outside the project are content roots of a trusted project only.
if project.content_roots() != roots {
project.refresh_index_scope();
let p = project.clone();
tokio::task::spawn_blocking(move || p.refresh_repositories());
project.sink.emit(ide_core::IdeEvent::ProjectRootsChanged { root: project.root.clone().into() });
}
if let Some(bridge) = &project.kotlin_bridge {
bridge.schedule();
}
@@ -332,7 +324,6 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
| "doc_edit"
| "doc_folding"
| "doc_highlights"
| "doc_language"
| "doc_open"
| "doc_open_untitled"
| "doc_open_virtual"
@@ -347,6 +338,7 @@ pub fn restricted_command_allowed(cmd: &str) -> bool {
| "doc_set_line_ending"
| "doc_snapshot"
| "doc_sync_from_disk"
| "doc_ui_mode"
| "syntax_errors"
| "syntax_expression_at"
| "syntax_identifiers"
+2 -2
Переглянути файл
@@ -68,7 +68,7 @@ done
}
for _ in 0..20 {
for window in ["first", "second"] {
let state = ops::agent::refresh_models(&host, window, "catalog-test".into(), true, None).unwrap();
let state = ops::agent::refresh_models(&host, window, "catalog-test".into(), true).unwrap();
assert!(state.refreshing);
}
}
@@ -87,7 +87,7 @@ done
assert!(completed.is_ok(), "both windows must receive the completed catalog");
for _ in 0..20 {
for window in ["first", "second"] {
let catalog = ops::agent::refresh_models(&host, window, "catalog-test".into(), true, None).unwrap();
let catalog = ops::agent::refresh_models(&host, window, "catalog-test".into(), true).unwrap();
assert!(!catalog.refreshing);
assert!(catalog.retry_at_ms.is_some());
let models = catalog.config.iter().find(|o| o.category.as_deref() == Some("model")).unwrap();
-44
Переглянути файл
@@ -69,47 +69,3 @@ async fn external_maven_link_persists_reloads_and_unlink_keeps_files() {
assert_eq!(std::fs::read_to_string(sibling.join("pom.xml")).unwrap(), b_pom);
host.shutdown().await;
}
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
async fn reactor_module_beside_a_trusted_project_is_a_content_root_until_removed() {
let temp = tempfile::tempdir().unwrap();
let base = dunce::canonicalize(temp.path()).unwrap();
let root = base.join("aggregator");
let service = base.join("service-a");
std::fs::create_dir_all(root.join("core")).unwrap();
std::fs::create_dir_all(&service).unwrap();
let reactor = |modules: &str| {
format!(
"<project><artifactId>aggregator</artifactId><packaging>pom</packaging><modules>{modules}</modules></project>"
)
};
std::fs::write(root.join("pom.xml"), reactor("<module>core</module><module>../service-a</module>")).unwrap();
std::fs::write(root.join("core/pom.xml"), "<project><artifactId>core</artifactId></project>").unwrap();
std::fs::write(service.join("pom.xml"), "<project><artifactId>service-a</artifactId></project>").unwrap();
let host = Host::new(HostConfig {
config_dir: base.join("config"),
data_dir: base.join("data"),
local_data_dir: base.join("local"),
languages: Arc::new(ide_language::LanguageRegistry::load(None).unwrap()),
syntax: Arc::default(),
sink_for: Box::new(|_| Arc::new(NullSink)),
owner: |window| window,
runtime: tokio::runtime::Handle::current(),
project_environment: false,
});
host.open_project("main", &root).unwrap();
let project = || host.project("main").unwrap();
assert!(project().content_roots().is_empty(), "Restricted Mode does not widen the index");
assert!(project().lsp.jdtls_import_roots().is_empty());
host.set_project_trust(&root, true, false).await.unwrap();
assert_eq!(project().content_roots(), vec![service.clone()]);
assert_eq!(project().lsp.jdtls_import_roots(), vec![service.clone()]);
std::fs::write(root.join("pom.xml"), reactor("<module>core</module>")).unwrap();
project().refresh_index_scope();
assert!(project().content_roots().is_empty());
assert!(project().lsp.jdtls_import_roots().is_empty());
assert!(service.join("pom.xml").is_file());
host.shutdown().await;
}
-21
Переглянути файл
@@ -481,27 +481,6 @@ async fn scope_limits_the_query_tools_to_a_directory() {
);
}
#[tokio::test(flavor = "multi_thread")]
async fn a_scoped_symbol_search_finds_matches_past_the_unscoped_ones() {
let h = Harness::new();
std::fs::create_dir_all(h.root.join("many")).unwrap();
for i in 0..60 {
std::fs::write(h.root.join(format!("many/m{i:02}.rs")), "pub fn pool_marker() {}\n").unwrap();
}
std::fs::create_dir_all(h.root.join("zz")).unwrap();
std::fs::write(h.root.join("zz/last.rs"), "pub fn pool_marker() {}\n").unwrap();
// Files written after the project opened reach the index through the watcher.
let deadline = std::time::Instant::now() + std::time::Duration::from_secs(20);
while h.json("search_symbol", json!({"q":"pool_marker","limit":100})).await["items"].as_array().map_or(0, Vec::len)
< 61
{
assert!(std::time::Instant::now() < deadline, "the files were never indexed");
tokio::time::sleep(std::time::Duration::from_millis(100)).await;
}
let found = h.json("search_symbol", json!({"q":"pool_marker","scope":"zz","limit":1})).await;
assert_eq!(found["items"][0]["filePath"], "zz/last.rs", "{found}");
}
#[tokio::test(flavor = "multi_thread")]
async fn scope_reaches_an_attached_worktree_the_repository_ignores() {
let h = Harness::new();
+1 -5
Переглянути файл
@@ -131,13 +131,9 @@ async fn returns_all_python_classes_and_bases() {
// Every returned entry is a Python file.
assert!(all.iter().all(|c| { matches!(c.path.0.extension().and_then(|e| e.to_str()), Some("py" | "pyi")) }));
// A file changed on disk is picked up once the index re-reads it. The index is the
// single source of truth for on-disk classes now; edits go through its update path
// (the IDE's file watcher calls this in production).
// A file changed on disk is parsed again; the others come from the cache.
let extra = p.root.join("src/extra.pyi");
std::fs::write(&extra, "class Stub(Child): ...\nclass Added(Base): ...\n").unwrap();
p.host.project(WINDOW).unwrap().index.update(std::slice::from_ref(&extra), &[]);
assert!(p.host.project(WINDOW).unwrap().index.wait_idle(Duration::from_secs(5)));
let again = ops::nav::nav_inheritance(&p.host, WINDOW).await.unwrap();
assert_eq!(find(&again, "Stub").bases, vec!["Child".to_string()]);
assert_eq!(find(&again, "Added").bases, vec!["Base".to_string()]);
+1 -2
Переглянути файл
@@ -80,8 +80,7 @@ impl Harness {
}
#[tokio::test(flavor = "multi_thread")]
async fn database_calls_enforce_grants_trust_ownership_and_uninstall_lifetime() {
// Nothing here tests the command budget, and a slow runner's first calls can exceed 250 ms.
let f = Harness::with_timeout(Duration::from_secs(10));
let f = Harness::new();
assert!(f.run("sources", None).is_err());
f.host.set_project_trust(&f.root, true, false).await.unwrap();
let source = f.source();
-1
Переглянути файл
@@ -54,7 +54,6 @@ fn method() -> SymbolTag {
kind: SymbolKind::Method,
container: None,
range: Range::new(Pos::new(0, 4), Pos::new(0, 8)),
bases: Vec::new(),
}
}
const SOURCE: &str = "def source:item\nref mapping:item\n";
-1
Переглянути файл
@@ -225,7 +225,6 @@ async fn indexed_usages_rename_preview_staleness_and_grouped_undo() {
kind: ide_core::SymbolKind::Method,
container: None,
range: ide_core::Range::new(Pos::new(0, 4), Pos::new(0, 5)),
bases: Vec::new(),
};
plugins
.index_navigation(
+2 -144
Переглянути файл
@@ -196,41 +196,6 @@ impl PluginWorkspace for TestWorkspace {
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 }) })
}
/// A Maven module with a lost version conflict, and a Gradle project with one report.
fn build_graph(&self, _root: &Path) -> Result<BuildGraph, HostError> {
let dep = |artifact: &str, version: &str| ide_build::MavenDependency {
group_id: "org.apache.commons".into(),
artifact_id: artifact.into(),
version: Some(version.into()),
scope: "compile".into(),
..Default::default()
};
let mut text = dep("commons-text", "1.11.0");
text.children = vec![ide_build::MavenDependency {
omitted: Some(ide_build::Omission::Conflict),
conflict_with: Some("3.14.0".into()),
..dep("commons-lang3", "3.12.0")
}];
let app = ide_build::MavenProject {
group_id: "com.example".into(),
artifact_id: "app".into(),
version: "1.0".into(),
dependencies: vec![text],
..Default::default()
};
let snakeyaml = ide_build::GradleDependency {
group: "org.yaml".into(),
name: "snakeyaml".into(),
requested: Some("2.2".into()),
..Default::default()
};
let report = ide_build::GradleReport {
project: ":web".into(),
configuration: "runtimeClasspath".into(),
dependencies: vec![snakeyaml],
};
Ok(BuildGraph { maven: vec![app], gradle: vec![GradleModule { path: ":web".into(), reports: vec![report] }] })
}
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() }
@@ -2186,60 +2151,6 @@ fn run_detectors_offer_granted_commands_in_marked_projects() {
assert!(detection.launch(config).unwrap_err().contains("no longer enabled"));
}
/// A plugin's Java agent (`[[contributes.javaAgents]]`, the `java-agent` fixture): an optional
/// high-risk `java.agent` capability; refusing or revoking it keeps the plugin working and the
/// launch gets no agent; granting it pins the jar, which may not change afterwards.
#[test]
fn java_agent_loads_only_while_granted_and_unchanged() {
let f = fixture(Limits::default());
let tmp = tempfile::tempdir().unwrap();
let pkg = tmp.path().join("java-agent");
copy_dir(&sample("java-agent"), &pkg);
let preview = f.host.preview_install(&pkg).unwrap();
let cap = preview.capabilities.iter().find(|c| c.id == "java.agent").expect("derived from the declaration");
assert!(cap.optional && cap.risk == ide_extension::Risk::High && !cap.granted);
assert_eq!(cap.description, "Run code inside the Java applications you start");
// Refused on install: the plugin is on, Java launches get no agent.
let info = f.host.install_from_dir(&pkg, &Consent::default()).unwrap();
assert_eq!(info.status, PluginStatus::Static, "{:?}", info.error);
assert!(info.contributions.iter().any(|c| c.point == "javaAgents" && c.label == "fixture agent.jar=mode=test"));
let source = f.host.java_agents();
let launch = || {
let agents = ide_run::java_agent::approved(&source.agents());
let mut args: Vec<String> = ["-Xmx1g", "-cp", "/p/classes", "app.Main"].map(String::from).into();
ide_run::java_agent::add_to_args(&mut args, &agents.options);
(args, agents.notes)
};
let plain: Vec<String> = ["-Xmx1g", "-cp", "/p/classes", "app.Main"].map(String::from).into();
assert_eq!(launch(), (plain.clone(), vec![]));
// Granted: the installed jar with its arguments, one argument after the VM options.
let info = f.host.set_capability("java-agent", "java.agent", true).unwrap();
assert!(info.capabilities.iter().any(|c| c.id == "java.agent" && c.granted));
let jar = dunce::canonicalize(f.installed("java-agent").join("agent/fixture agent.jar")).unwrap();
let option = format!("-javaagent:{}=mode=test", jar.display());
let mut with_agent = plain.clone();
with_agent.insert(3, option.clone());
assert_eq!(launch(), (with_agent.clone(), vec![]));
// The jar changed since it was granted: left out, with a reason, until approved again.
std::fs::write(&jar, "swapped").unwrap();
let (args, notes) = launch();
assert_eq!(args, plain);
assert!(notes.len() == 1 && notes[0].contains("changed since it was approved"), "{notes:?}");
f.host.set_capability("java-agent", "java.agent", true).unwrap();
assert_eq!(launch(), (with_agent.clone(), vec![]));
// Revoked, then the plugin disabled: no agent either way.
f.host.set_capability("java-agent", "java.agent", false).unwrap();
assert_eq!(f.status("java-agent"), PluginStatus::Static);
assert_eq!(launch(), (plain.clone(), vec![]));
f.host.set_capability("java-agent", "java.agent", true).unwrap();
f.host.set_enabled("java-agent", false).unwrap();
assert_eq!(launch(), (plain, vec![]));
}
/// Compiled components are cached across runs (keyed by module and
/// engine), so a cold activation only deserializes.
#[test]
@@ -6607,8 +6518,8 @@ fn a_plugin_command_opens_a_diff_in_its_window() {
client.as_deref() == Some("main")
&& matches!(event, PluginEvent::OpenDiff { plugin_id, diff, file_name }
if plugin_id == "execution"
&& diff.left.as_deref() == Some("before\n")
&& diff.right.as_deref() == Some("after\n")
&& diff.left == "before\n"
&& diff.right == "after\n"
&& diff.title.as_deref() == Some("Review")
&& file_name.as_deref() == Some("src/review.rs"))
})
@@ -7111,59 +7022,6 @@ fn the_language_server_grant_needs_api_1_9() {
assert!(err.message.contains("new in plugin API 1.9"), "{err:?}");
}
/// `build.dependencies` hands a plugin the resolved Maven / Gradle graph as a flat list, each
/// module a root, with `build.read` in a trusted project (API 1.10).
#[test]
fn build_dependencies_need_the_grant_and_a_trusted_project() {
let f = fixture(Limits::default());
let id = "test.build-graph";
let info = f.install(&sample("build-graph"));
assert!(info.capabilities.iter().any(|c| c.id == "build.read" && c.granted && c.risk == ide_extension::Risk::Low));
// `parent group:artifact:version scope status requested`, as the fixture prints them.
assert_eq!(
f.run(id, "dependencies", None).unwrap().unwrap(),
"- com.example:app:1.0 resolved -\n\
0 org.apache.commons:commons-text:1.11.0 compile resolved -\n\
1 org.apache.commons:commons-lang3:3.14.0 compile conflict 3.12.0\n\
- ::web: resolved -\n\
3 org.yaml:snakeyaml:2.2 runtimeClasspath resolved -"
);
assert_eq!(
f.run(id, "dependencies", Some(":web")).unwrap().unwrap(),
"- ::web: resolved -\n0 org.yaml:snakeyaml:2.2 runtimeClasspath resolved -"
);
let err = f.host.run_command(id, "dependencies", Some("app"), f.inv()).unwrap_err();
assert_eq!(err.kind, ErrorKind::NotFound, "{err:?}");
f.host.set_capability(id, "build.read", false).unwrap();
let err = f.host.run_command(id, "dependencies", None, f.inv()).unwrap_err();
assert_eq!(err.kind, ErrorKind::PermissionDenied, "{err:?}");
assert!(err.message.contains("build.read"), "{err:?}");
f.host.set_capability(id, "build.read", true).unwrap();
// The graph comes from running the project's build: 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));
let err = f.host.run_command(id, "dependencies", None, f.inv()).unwrap_err();
assert_eq!(err.kind, ErrorKind::PermissionDenied, "{err:?}");
assert_eq!(f.host.info_of(id).unwrap().stats.crashes, 0);
}
/// The grant is new in API 1.10: an older `engines.openidea` can't ask for it.
#[test]
fn the_build_grant_needs_api_1_10() {
let f = fixture(Limits::default());
let tmp = tempfile::tempdir().unwrap();
let pkg = tmp.path().join("build-graph");
copy_dir(&sample("build-graph"), &pkg);
let manifest = std::fs::read_to_string(pkg.join("plugin.toml")).unwrap();
std::fs::write(pkg.join("plugin.toml"), manifest.replace("\"^1.10\"", "\"^1.9\"")).unwrap();
let err = f.host.install_from_dir(&pkg, &Consent::all()).unwrap_err();
assert!(err.message.contains("new in plugin API 1.10"), "{err:?}");
}
/// The UI's synthetic post-install `SettingsChanged([])` reaches a plugin that
/// subscribes to `on-event:settings-changed`, though it carries no keys.
#[test]
+1 -44
Переглянути файл
@@ -106,9 +106,6 @@ pub(crate) struct StoredSymbol {
pub kind: SymbolKind,
pub container: Option<String>,
pub range: Range,
/// Base names of a class definition; empty for every other symbol.
#[serde(default)]
pub bases: Vec<String>,
}
/// A symbol resolved out of [`SymTable`].
@@ -117,8 +114,6 @@ pub(crate) struct SymRef<'a> {
pub kind: SymbolKind,
pub container: Option<&'a str>,
pub range: Range,
/// Base names joined with `'\0'`; empty when the symbol has none.
pub bases: &'a str,
}
pub(crate) struct FileEntry {
@@ -407,8 +402,6 @@ pub(crate) struct SymTable {
container: Vec<Span>,
kind: Vec<SymbolKind>,
range: Vec<Range>,
/// Base names joined with `'\0'`, one interned span per symbol (`NONE` for none).
bases: Vec<Span>,
text: String,
dead_rows: usize,
}
@@ -430,18 +423,6 @@ impl SymTable {
(span.start != u32::MAX).then(|| span.get(&self.text))
}
/// The symbol's base names joined with `'\0'`; empty when it has none.
#[inline]
pub(crate) fn bases(&self, i: u32) -> &str {
let span = self.bases[i as usize];
if span.start == u32::MAX { "" } else { span.get(&self.text) }
}
/// The base names of row `i`, split out of the interned string.
pub(crate) fn base_list(&self, i: u32) -> Vec<&str> {
self.bases(i).split('\0').filter(|b| !b.is_empty()).collect()
}
/// The mask + name rows of a file's contiguous symbol range.
#[inline]
pub(crate) fn heads(&self, start: u32, len: u32) -> &[SymHead] {
@@ -478,12 +459,10 @@ impl SymTable {
Some(c) => self.intern(c),
None => Span::NONE,
};
let bases = if s.bases.is_empty() { Span::NONE } else { self.intern(&s.bases.join("\0")) };
self.head.push(SymHead { mask, name });
self.container.push(container);
self.kind.push(s.kind);
self.range.push(s.range);
self.bases.push(bases);
}
(start, agg_mask)
}
@@ -497,7 +476,6 @@ impl SymTable {
&& self.container(i) == s.container.as_deref()
&& self.kind(i) == s.kind
&& self.range(i) == s.range
&& self.base_list(i) == s.bases.iter().map(String::as_str).collect::<Vec<_>>()
})
}
@@ -514,7 +492,6 @@ impl SymTable {
let mut container = Vec::with_capacity(head.capacity());
let mut kind = Vec::with_capacity(head.capacity());
let mut range = Vec::with_capacity(head.capacity());
let mut bases = Vec::with_capacity(head.capacity());
let mut live = 0u32;
for (slot, row) in rows.iter_mut().enumerate() {
if !row.live {
@@ -541,14 +518,6 @@ impl SymTable {
}
kind.push(self.kind[i as usize]);
range.push(self.range[i as usize]);
let bases_span = self.bases[i as usize];
if bases_span.start == u32::MAX {
bases.push(Span::NONE);
} else {
let b = bases_span.get(&self.text);
bases.push(Span::of(&text, b));
text.push_str(b);
}
live += 1;
}
}
@@ -556,7 +525,6 @@ impl SymTable {
self.container = container;
self.kind = kind;
self.range = range;
self.bases = bases;
self.text = text;
self.dead_rows = 0;
}
@@ -566,7 +534,6 @@ impl SymTable {
self.container.shrink_to_fit();
self.kind.shrink_to_fit();
self.range.shrink_to_fit();
self.bases.shrink_to_fit();
self.text.shrink_to_fit();
}
}
@@ -610,7 +577,6 @@ impl IndexData {
self.syms.container.reserve(symbols);
self.syms.kind.reserve(symbols);
self.syms.range.reserve(symbols);
self.syms.bases.reserve(symbols);
}
/// Hydrates a validated warm-start snapshot in one pass, without per-file
@@ -674,7 +640,6 @@ impl IndexData {
kind: s.kind,
container: s.container.map(str::to_owned),
range: s.range,
bases: s.bases.split('\0').filter(|b| !b.is_empty()).map(str::to_owned).collect(),
})
.collect(),
ignored: e.ignored,
@@ -701,7 +666,6 @@ impl IndexData {
kind: syms.kind(i),
container: syms.container(i),
range: syms.range(i),
bases: syms.bases(i),
})
}
@@ -859,7 +823,6 @@ mod tests {
kind: SymbolKind::Function,
container: None,
range: Range::default(),
bases: Vec::new(),
})
.collect(),
..Default::default()
@@ -994,13 +957,7 @@ mod tests {
}
fn symbol(n: &str) -> StoredSymbol {
StoredSymbol {
name: n.to_owned(),
kind: SymbolKind::Function,
container: None,
range: Range::default(),
bases: Vec::new(),
}
StoredSymbol { name: n.to_owned(), kind: SymbolKind::Function, container: None, range: Range::default() }
}
#[test]
-35
Переглянути файл
@@ -50,17 +50,6 @@ pub struct SymbolMatch {
pub indices: MatchIndices,
}
/// A class declaration of the index and the base names written in its source.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct ClassDecl {
pub path: PathBuf,
pub name: String,
/// Selection range: the class name's identifier.
pub range: Range,
/// Bare base names, as written (`class X(pkg.mod.Base)` keeps `Base`).
pub bases: Vec<String>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub enum SymbolFilter {
@@ -217,34 +206,11 @@ impl ProjectIndex {
kind: s.kind,
container: s.container.map(ToString::to_string),
range: s.range,
bases: s.bases.split('\0').filter(|b| !b.is_empty()).map(str::to_owned).collect(),
})
.collect(),
)
}
/// Every class declaration of the indexed project (content roots included) with the
/// base names written in its source, in path order. The UI builds an inheritance
/// graph from it, so it needs no language server's type hierarchy.
pub fn inheritance(&self) -> Vec<ClassDecl> {
let data = self.shared.data.read();
let mut out = Vec::new();
for entry in data.files.iter().flatten() {
for s in data.symbols_of(entry) {
if s.kind != SymbolKind::Class {
continue;
}
out.push(ClassDecl {
path: entry.path.clone(),
name: s.name.to_owned(),
range: s.range,
bases: s.bases.split('\0').filter(|b| !b.is_empty()).map(str::to_owned).collect(),
});
}
}
out
}
/// Bounded file inventory for background plugin indexers; honors the same
/// project/exclude scope as search and never walks the filesystem.
pub fn files_with_extensions(&self, extensions: &[String], limit: usize) -> Vec<PathBuf> {
@@ -551,7 +517,6 @@ pub mod bench_support {
kind: if k % 3 == 0 { SymbolKind::Class } else { SymbolKind::Method },
container: (k % 3 != 0).then(|| format!("{w}{s}")),
range: Range::default(),
bases: Vec::new(),
})
.collect();
let record = FileRecord { symbols, ..Default::default() };
+2 -14
Переглянути файл
@@ -11,8 +11,8 @@ use std::time::{SystemTime, UNIX_EPOCH};
const FILES: TableDefinition<&str, &[u8]> = TableDefinition::new("files");
const META: TableDefinition<&str, &[u8]> = TableDefinition::new("meta");
/// Bump when [`FileRecord`] or its encoding changes. 4: a symbol's base names.
const SCHEMA: &str = "openidea-index-4";
/// Bump when [`FileRecord`] or its encoding changes.
const SCHEMA: &str = "openidea-index-3";
/// The real Git directory for a checkout/worktree (`root/.git` may be a file
/// containing `gitdir: ...`).
@@ -113,9 +113,6 @@ struct FlatSymbol {
name_len: u32,
container_start: u32,
container_len: u32,
/// Base names joined with `'\0'` (`bases_len` 0 when the symbol has none).
bases_start: u32,
bases_len: u32,
kind: SymbolKind,
range: Range,
}
@@ -327,14 +324,11 @@ impl Snapshot {
let start = s.container_start as usize;
&self.text[start..start + s.container_len as usize]
});
let bases_start = s.bases_start as usize;
let bases = &self.text[bases_start..bases_start + s.bases_len as usize];
StoredSymbol {
name: name.to_owned(),
kind: s.kind,
container: container.map(str::to_owned),
range: s.range,
bases: bases.split('\0').filter(|b| !b.is_empty()).map(str::to_owned).collect(),
}
})
.collect();
@@ -504,15 +498,11 @@ impl Store {
}
None => (u32::MAX, 0),
};
let bases_start = fit(snap.text.len())?;
snap.text.push_str(s.bases);
snap.symbols.push(FlatSymbol {
name_start,
name_len: fit(s.name.len())?,
container_start,
container_len,
bases_start,
bases_len: fit(s.bases.len())?,
kind: s.kind,
range: s.range,
});
@@ -727,7 +717,6 @@ mod tests {
kind: SymbolKind::Class,
container: Some("Order".into()),
range: Range::default(),
bases: vec!["Base".into()],
}],
..Default::default()
};
@@ -751,7 +740,6 @@ mod tests {
assert_eq!(symbols.len(), 1);
assert_eq!(symbols[0].name, "OrderController");
assert_eq!(symbols[0].container.as_deref(), Some("Order"));
assert_eq!(symbols[0].bases, vec!["Base".to_string()], "bases survive the snapshot");
store.apply(&[], &[], false).unwrap();
assert!(store.load_snapshot().is_none(), "a file change invalidates the snapshot");
-23
Переглянути файл
@@ -567,29 +567,6 @@ fn symbols_named_any_answers_every_name_inside_the_root_in_one_walk() {
assert_eq!(found, expected.map(|(name, path)| (name.to_string(), path.to_string())));
}
#[test]
fn inheritance_reports_python_classes_and_their_bases() {
let f = Fixture::new(&[(
"app.py",
"class Base:\n pass\n\nclass Child(Base, other.Mixin):\n pass\n\nclass Plain:\n pass\n",
)]);
let idx = f.open();
let mut found: Vec<(String, u32, Vec<String>)> =
idx.inheritance().into_iter().map(|c| (c.name, c.range.start.line, c.bases)).collect();
found.sort();
assert_eq!(
found,
vec![
("Base".to_string(), 0, Vec::new()),
("Child".to_string(), 3, vec!["Base".to_string(), "Mixin".to_string()]),
("Plain".to_string(), 6, Vec::new()),
]
);
// Every class of the project is reported, even without a superclass: the UI needs
// them to resolve the base names of other files.
assert_eq!(idx.inheritance().len(), 3);
}
#[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")]);
+1 -7
Переглянути файл
@@ -752,13 +752,7 @@ impl Shared {
.syntax
.tags(&lang, &text)
.into_iter()
.map(|t| StoredSymbol {
name: t.name,
kind: t.kind,
container: t.container,
range: t.range,
bases: t.bases,
})
.map(|t| StoredSymbol { name: t.name, kind: t.kind, container: t.container, range: t.range })
.collect();
}
Extracted::New(rec)
+3 -1
Переглянути файл
@@ -8,6 +8,8 @@ license.workspace = true
[dependencies]
futures.workspace = true
serde.workspace = true
serde_json.workspace = true
specta.workspace = true
thiserror.workspace = true
[dev-dependencies]
serde_json.workspace = true
-11
Переглянути файл
@@ -2,10 +2,8 @@
//! suspended. Implementations live elsewhere (jdtls bundle for Java, JDWP link for Kotlin).
mod names;
mod stream;
pub use names::{is_boxed, name_to_signature, signature_to_name, string_length};
pub use stream::{AbortState, CollectedTerminal, StreamTracer, TraceCollected, TraceId, TraceState};
use futures::future::BoxFuture;
use serde::{Deserialize, Serialize};
@@ -114,15 +112,6 @@ pub enum InspectError {
VmNotFound,
#[error("not supported by this debug adapter: {0}")]
Unsupported(String),
#[error("java-debug has no debug session for this JVM")]
NoSession,
/// The bundle's reason, e.g. which line the chain starts on.
#[error("the debuggee is not stopped where the stream chain starts: {0}")]
NotAtChainStart(String),
#[error("a stream trace is already running in this JVM")]
Busy,
#[error("there is no such stream trace in this JVM")]
NoTrace,
#[error("the request timed out")]
TimedOut,
#[error("the connection was closed")]
-89
Переглянути файл
@@ -1,89 +0,0 @@
//! Tracing a stream chain while the program itself runs it. One trace per VM; the trace's records
//! are read back once the debuggee is suspended again.
use crate::{InspectFuture, JvmValue, VmTarget};
use serde::{Deserialize, Serialize};
use specta::Type;
/// Assigned by the debuggee-side bundle; valid for one VM.
pub type TraceId = u64;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TraceState {
Running {
records: u64,
dropped: u64,
elapsed_ms: u64,
},
/// The terminal operation finished and the thread is suspended again, ready to `collect`.
Parked {
records: u64,
dropped: u64,
},
Failed {
detail: String,
},
/// Stopped or aborted before the terminal operation ran: taken down, the program untouched.
Cancelled {
detail: String,
},
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(tag = "kind", rename_all = "camelCase", rename_all_fields = "camelCase")]
pub enum AbortState {
Interrupted,
Stopped,
/// Suspended threads that own a monitor the terminal may be waiting for: `(thread id, name)`.
Stuck {
holders: Vec<(i64, String)>,
},
/// The terminal had not started.
Cancelled,
/// The trace had already parked or failed.
Finished,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum CollectedTerminal {
Value(JvmValue),
Void,
Threw(JvmValue),
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct TraceCollected {
/// `(step, value)`: step counts the wrapped ops from 0 (the source).
pub records: Vec<(u16, JvmValue)>,
/// Records past the arm-time budget; counted, not kept.
pub dropped: u64,
pub terminal: CollectedTerminal,
pub skipped_breakpoints: u32,
/// A parallel chain was forced to run sequentially so that records keep their order.
pub sequentialized: bool,
}
pub trait StreamTracer: Send + Sync {
/// `plan` is the JSON of `ide_streams::RealRunPlan`; `budget` caps the records kept. `token`
/// names the trace for [`release_armed`](Self::release_armed) when no reply arrives.
fn arm<'a>(
&'a self,
target: &'a VmTarget,
thread_id: i64,
plan: &'a serde_json::Value,
budget: u32,
token: &'a str,
) -> InspectFuture<'a, TraceId>;
/// Blocks up to `ms` milliseconds for the trace to leave `Running`.
fn wait<'a>(&'a self, target: &'a VmTarget, trace: TraceId, ms: u32) -> InspectFuture<'a, TraceState>;
/// Stops keeping records while the terminal keeps running; returns the records kept so far.
fn stop<'a>(&'a self, target: &'a VmTarget, trace: TraceId) -> InspectFuture<'a, u64>;
fn abort<'a>(&'a self, target: &'a VmTarget, trace: TraceId) -> InspectFuture<'a, AbortState>;
/// `target.generation` must be a stop after the trace parked. `records`: how many it parked
/// with; reading each takes a round trip to the JVM, so the time allowed grows with them.
fn collect<'a>(&'a self, target: &'a VmTarget, trace: TraceId, records: u64) -> InspectFuture<'a, TraceCollected>;
fn release<'a>(&'a self, target: &'a VmTarget, trace: TraceId) -> InspectFuture<'a, ()>;
/// Releases the trace armed with `token` whose `arm` reply never came (it timed out); nothing
/// when there is none.
fn release_armed<'a>(&'a self, target: &'a VmTarget, token: &'a str) -> InspectFuture<'a, ()>;
}
-24
Переглянути файл
@@ -73,21 +73,6 @@ pub struct LanguageConfig {
/// Content of a new scratch file; `$END$` marks where the caret goes.
#[serde(default)]
pub scratch_template: Option<String>,
/// Syntax nodes of the editor's grammar whose `<` `>` rainbow brackets colour.
#[serde(default)]
pub rainbow_brackets: RainbowBracketNodes,
}
/// `[rainbow-brackets]` of a language definition: node names of its editor (Lezer)
/// grammar, so angle brackets are coloured only where the syntax tree says they
/// delimit something, never in comparisons or shifts.
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(default)]
pub struct RainbowBracketNodes {
/// Nodes spanning `<` … `>` whose delimiters pair up: type argument and parameter lists.
pub angle: Vec<String>,
/// Markup tags (`<a>`, `</a>`, `<a/>`); an element's start and end tags pair up.
pub tags: Vec<String>,
}
/// An external formatting tool and its language-specific parser.
@@ -317,10 +302,6 @@ pub struct LanguageInfo {
#[serde(default)]
#[specta(optional)]
pub scratch_template: Option<String>,
/// Syntax nodes whose `<` `>` rainbow brackets colour (Color Scheme › Rainbow brackets).
#[serde(default)]
#[specta(optional)]
pub rainbow_brackets: RainbowBracketNodes,
}
impl From<&LanguageConfig> for LanguageInfo {
@@ -338,7 +319,6 @@ impl From<&LanguageConfig> for LanguageInfo {
filenames: c.filenames.clone(),
first_line: c.first_line.clone(),
scratch_template: c.scratch_template.clone(),
rainbow_brackets: c.rainbow_brackets.clone(),
}
}
}
@@ -367,10 +347,6 @@ pub struct SymbolTag {
/// Enclosing symbol, e.g. class name for a method.
pub container: Option<String>,
pub range: Range,
/// Bare base names written in a class definition (`class X(A, B)`); empty for
/// every other symbol, and for languages whose classes carry none.
#[serde(default)]
pub bases: Vec<String>,
}
/// One inline TS/JS `<script>` block of a Vue SFC / HTML document.
-14
Переглянути файл
@@ -667,20 +667,6 @@ mod tests {
assert_eq!(rust.language_servers[0].name, "rust-analyzer");
}
#[test]
fn rainbow_bracket_nodes_reach_the_ui() {
let reg = reg();
let tsx = reg.get(&LanguageId::new("typescriptreact")).unwrap();
assert_eq!(tsx.rainbow_brackets.angle, ["TypeArgList", "TypeParamList"]);
assert!(tsx.rainbow_brackets.tags.iter().any(|t| t == "JSXOpenTag"));
let info = crate::LanguageInfo::from(&reg.get(&LanguageId::new("html")).unwrap());
assert_eq!(info.rainbow_brackets.tags, ["OpenTag", "CloseTag", "SelfClosingTag"]);
let json = serde_json::to_value(&info).unwrap();
assert_eq!(json["rainbowBrackets"]["tags"][0], "OpenTag");
// Definitions without the table, as most are, get none.
assert_eq!(reg.get(&LanguageId::new("python")).unwrap().rainbow_brackets, Default::default());
}
#[test]
fn alternative_servers_are_fallbacks() {
let reg = reg();
+3 -18
Переглянути файл
@@ -67,10 +67,9 @@ fn visit(cursor: &mut tree_sitter::TreeCursor, f: &mut impl FnMut(Node)) {
}
}
/// Bare base names of a `class_definition` node (`[]` without a superclass list).
/// Shared with the outline query, whose tags carry the bases of a class definition.
pub(super) fn class_base_names(class: Node, text: &str) -> Vec<String> {
class.child_by_field_name("superclasses").map(|args| base_names(args, text)).unwrap_or_default()
/// The bare base names a `class_definition` node writes (keyword arguments left out).
pub(super) fn class_base_names(node: Node, text: &str) -> Vec<String> {
node.child_by_field_name("superclasses").map(|args| base_names(args, text)).unwrap_or_default()
}
fn base_names(args: Node, text: &str) -> Vec<String> {
@@ -122,20 +121,6 @@ mod tests {
assert_eq!(shape("class A: pass"), vec![("A".to_owned(), 0, 6, vec![])]);
}
/// The project index stores bases on the symbol tags, so the outline query must
/// carry them too (one parse for both, not a second pass over every file).
#[test]
fn tags_carry_class_bases() {
static S: std::sync::OnceLock<Syntax> = std::sync::OnceLock::new();
let s = S.get_or_init(Syntax::new);
let tags = s.tags(&LanguageId::new("python"), "class A: pass\nclass B(A, pkg.C):\n def m(self): pass\n");
let bases_of = |name: &str| tags.iter().find(|t| t.name == name).map(|t| t.bases.clone()).unwrap_or_default();
assert!(bases_of("A").is_empty());
assert_eq!(bases_of("B"), vec!["A".to_owned(), "C".to_owned()]);
// Only classes carry bases; the method's tag stays empty.
assert!(bases_of("m").is_empty());
}
#[test]
fn multiple_bases_skips_metaclass() {
assert_eq!(
+3 -34
Переглянути файл
@@ -73,33 +73,6 @@ pub struct SpellingRegion {
pub start: usize,
pub end: usize,
pub kind: SpellingKind,
/// A raw / verbatim string: backslashes are literal text, not escapes
/// (`r"\user"`, `r#"…"#`, `` `…` ``, `@"…"`). The spelling layer must not
/// skip the character after a `\` in one of these.
pub raw: bool,
}
/// Whether `node` is a string literal whose backslashes are not escapes.
fn is_raw_string(node: &Node<'_>, text: &str) -> bool {
let kind = node.kind();
// Rust/C++/C# grammars name the node directly.
if kind == "raw_string_literal" || kind == "verbatim_string_literal" || kind.contains("raw_string") {
return true;
}
// Go backtick strings and Python `r`/`fr`/`rb` prefixes: the grammar uses
// the generic `string` node, so inspect the literal's own prefix.
if kind == "string" || kind == "string_literal" {
let literal = &text[node.start_byte()..node.end_byte()];
if literal.starts_with('`') {
return true;
}
let quote = literal.find(['"', '\'']);
let prefix = quote.map_or("", |i| &literal[..i]);
return !prefix.is_empty()
&& prefix.chars().any(|c| c == 'r' || c == 'R')
&& prefix.chars().all(|c| matches!(c, 'r' | 'R' | 'b' | 'B' | 'f' | 'F' | 'u' | 'U'));
}
false
}
fn is_name_leaf(kind: &str) -> bool {
@@ -128,20 +101,16 @@ fn declares(cursor: &TreeCursor<'_>, node: &Node<'_>) -> bool {
}
/// Comments, string literals and declared names, for spell checking.
pub(crate) fn spelling_regions(tree: &Tree, text: &str) -> Vec<SpellingRegion> {
pub(crate) fn spelling_regions(tree: &Tree) -> Vec<SpellingRegion> {
let mut out = Vec::new();
let mut cursor = tree.walk();
loop {
let node = cursor.node();
let literal = kind_of(&node);
let region = |kind| SpellingRegion { start: node.start_byte(), end: node.end_byte(), kind, raw: false };
let region = |kind| SpellingRegion { start: node.start_byte(), end: node.end_byte(), kind };
match literal {
Some(LiteralKind::Comment) => out.push(region(SpellingKind::Comment)),
Some(LiteralKind::String) => {
let mut r = region(SpellingKind::String);
r.raw = is_raw_string(&node, text);
out.push(r);
}
Some(LiteralKind::String) => out.push(region(SpellingKind::String)),
None if node.is_named()
&& node.child_count() == 0
&& is_name_leaf(node.kind())
+1 -1
Переглянути файл
@@ -294,7 +294,7 @@ impl Syntax {
/// Comments, string literals and declared names (byte ranges, document
/// order) for the Typo inspection; `None` like [`Self::literals`].
pub fn spelling_regions(&self, lang: &LanguageId, text: &str) -> Option<Vec<SpellingRegion>> {
self.analyze(lang, text, |_, tree, text| Some(literals::spelling_regions(tree, text)))
self.analyze(lang, text, |_, tree, _| Some(literals::spelling_regions(tree)))
}
/// Syntax-aware selection ranges for IDEA "Extend Selection" (⌥↑), innermost first.
-10
Переглянути файл
@@ -143,8 +143,6 @@ struct Raw {
visibility: Option<Visibility>,
/// Rust `impl Trait for Type`: members take the trait's visibility.
trait_impl: bool,
/// Base names of a class definition (empty where the grammar has none).
bases: Vec<String>,
}
struct Built {
@@ -223,13 +221,6 @@ fn collect(g: &Grammar, q: &OutlineQuery, tree: &Tree, text: &str) -> Vec<Built>
detail: detail.map(|d| clean(node_text(&d, text), 80)).filter(|d| !d.is_empty()),
visibility: explicit_visibility(&node, text),
trait_impl,
// The index needs every class's bases; Python is the grammar that has them.
bases: match kind {
ItemKind::Symbol(SymbolKind::Class) if g.spec.name == "python" => {
super::inheritance::class_base_names(node, text)
}
_ => Vec::new(),
},
};
match by_node.get(&raw.node_id) {
Some(existing) if existing.pattern <= raw.pattern => {}
@@ -378,7 +369,6 @@ pub(crate) fn tags(g: &Grammar, q: &OutlineQuery, tree: &Tree, text: &str) -> Ve
kind: b.kind,
container: own_container.map(str::to_owned),
range: b.raw.sel,
bases: b.raw.bases.clone(),
});
}
let next = if b.raw.tag || matches!(b.raw.kind, ItemKind::Impl | ItemKind::Extension) {
-29
Переглянути файл
@@ -1422,35 +1422,6 @@ fn spelling_regions_cover_declared_names_only() {
assert_eq!(names, ["Bird", "fly", "text"]);
}
#[test]
fn spelling_regions_mark_raw_strings() {
let py = r#"a = r"\user" + R'\mesage' + fr"\wrd" + rb"\foo" + "\user""#;
let found: Vec<(&str, bool)> = syntax()
.spelling_regions(&lang("python"), py)
.unwrap()
.iter()
.filter(|r| r.kind == SpellingKind::String)
.map(|r| (&py[r.start..r.end], r.raw))
.collect();
assert_eq!(
found,
vec![
(r#"r"\user""#, true),
(r"R'\mesage'", true),
(r#"fr"\wrd""#, true),
(r#"rb"\foo""#, true),
(r#""\user""#, false),
]
);
// C# verbatim / Rust raw literals are named by the grammar itself.
let cs = r#"var s = @"C:\mesage";"#;
let raw = syntax().spelling_regions(&lang("csharp"), cs).unwrap().iter().any(|r| r.raw);
assert!(raw, "C# verbatim string should be raw");
let rs = r#"let s = r"\mesage";"#;
let raw = syntax().spelling_regions(&lang("rust"), rs).unwrap().iter().any(|r| r.raw);
assert!(raw, "Rust raw string should be raw");
}
// ---------------------------------------------------------------------------
// Script regions of Vue SFCs and HTML documents
+1 -1
Переглянути файл
@@ -129,7 +129,7 @@ pub(crate) fn definitions(g: &Grammar, css: Option<&Grammar>, tree: &Tree, text:
};
if let Some((name, kind)) = def {
let range = idx.range(base + n.start_byte(), base + n.end_byte());
out.push(SymbolTag { name, kind, container: None, range, bases: Vec::new() });
out.push(SymbolTag { name, kind, container: None, range });
}
true
});
-5
Переглянути файл
@@ -1,5 +0,0 @@
doctrine-mapping.xsd is from Doctrine ORM (https://github.com/doctrine/orm),
MIT License. Copyright (c) Doctrine Project.
The copy published at https://www.doctrine-project.org/schemas/orm/doctrine-mapping.xsd
is broken (wrong targetNamespace / XMLSchema URI after an http→https rewrite);
this file is the upstream schema with the correct namespace.
-643
Переглянути файл
@@ -1,643 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://doctrine-project.org/schemas/orm/doctrine-mapping"
xmlns:orm="http://doctrine-project.org/schemas/orm/doctrine-mapping"
elementFormDefault="qualified">
<xs:annotation>
<xs:documentation><![CDATA[
This is the XML Schema for the object/relational
mapping file used by the Doctrine ORM.
]]></xs:documentation>
</xs:annotation>
<xs:element name="doctrine-mapping">
<xs:complexType>
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="mapped-superclass" type="orm:mapped-superclass" minOccurs="0" maxOccurs="unbounded" />
<xs:element name="entity" type="orm:entity" minOccurs="0" maxOccurs="unbounded" />
<xs:element name="embeddable" type="orm:embeddable" minOccurs="0" maxOccurs="unbounded" />
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
</xs:element>
<xs:complexType name="emptyType">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="cascade-type">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="cascade-all" type="orm:emptyType" minOccurs="0"/>
<xs:element name="cascade-persist" type="orm:emptyType" minOccurs="0"/>
<xs:element name="cascade-merge" type="orm:emptyType" minOccurs="0"/>
<xs:element name="cascade-remove" type="orm:emptyType" minOccurs="0"/>
<xs:element name="cascade-refresh" type="orm:emptyType" minOccurs="0"/>
<xs:element name="cascade-detach" type="orm:emptyType" minOccurs="0"/>
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:simpleType name="lifecycle-callback-type">
<xs:restriction base="xs:token">
<xs:enumeration value="prePersist"/>
<xs:enumeration value="postPersist"/>
<xs:enumeration value="preUpdate"/>
<xs:enumeration value="postUpdate"/>
<xs:enumeration value="preRemove"/>
<xs:enumeration value="postRemove"/>
<xs:enumeration value="postLoad"/>
<xs:enumeration value="preFlush"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="cache-usage-type">
<xs:restriction base="xs:token">
<xs:enumeration value="READ_ONLY"/>
<xs:enumeration value="READ_WRITE"/>
<xs:enumeration value="NONSTRICT_READ_WRITE"/>
</xs:restriction>
</xs:simpleType>
<xs:complexType name="lifecycle-callback">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="type" type="orm:lifecycle-callback-type" use="required" />
<xs:attribute name="method" type="xs:NMTOKEN" use="required" />
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="lifecycle-callbacks">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="lifecycle-callback" type="orm:lifecycle-callback" minOccurs="1" maxOccurs="unbounded" />
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="named-query">
<xs:attribute name="name" type="xs:string" use="required" />
<xs:attribute name="query" type="xs:string" use="required" />
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="named-queries">
<xs:sequence>
<xs:element name="named-query" type="orm:named-query" minOccurs="1" maxOccurs="unbounded" />
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="named-native-query">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="query" type="xs:string" minOccurs="1" maxOccurs="1"/>
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="name" type="xs:string" use="required" />
<xs:attribute name="result-class" type="orm:fqcn" />
<xs:attribute name="result-set-mapping" type="xs:string" />
</xs:complexType>
<xs:complexType name="named-native-queries">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="named-native-query" type="orm:named-native-query" minOccurs="1" maxOccurs="unbounded" />
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
</xs:complexType>
<xs:complexType name="entity-listener">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="lifecycle-callback" type="orm:lifecycle-callback" minOccurs="0" maxOccurs="unbounded"/>
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="class" type="orm:fqcn"/>
</xs:complexType>
<xs:complexType name="entity-listeners">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="entity-listener" type="orm:entity-listener" minOccurs="1" maxOccurs="unbounded" />
</xs:choice>
</xs:complexType>
<xs:complexType name="column-result">
<xs:attribute name="name" type="xs:string" use="required" />
</xs:complexType>
<xs:complexType name="field-result">
<xs:attribute name="name" type="xs:string" use="required" />
<xs:attribute name="column" type="xs:string" />
</xs:complexType>
<xs:complexType name="entity-result">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="field-result" type="orm:field-result" minOccurs="0" maxOccurs="unbounded" />
</xs:choice>
<xs:attribute name="entity-class" type="orm:fqcn" use="required" />
<xs:attribute name="discriminator-column" type="xs:string" use="optional" />
</xs:complexType>
<xs:complexType name="sql-result-set-mapping">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="entity-result" type="orm:entity-result"/>
<xs:element name="column-result" type="orm:column-result"/>
</xs:choice>
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="name" type="xs:string" use="required" />
</xs:complexType>
<xs:complexType name="sql-result-set-mappings">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="sql-result-set-mapping" type="orm:sql-result-set-mapping" minOccurs="1" maxOccurs="unbounded" />
</xs:choice>
</xs:complexType>
<xs:complexType name="cache">
<xs:attribute name="usage" type="orm:cache-usage-type" />
<xs:attribute name="region" type="xs:string" />
</xs:complexType>
<xs:complexType name="entity">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="cache" type="orm:cache" minOccurs="0" maxOccurs="1"/>
<xs:element name="options" type="orm:options" minOccurs="0" />
<xs:element name="indexes" type="orm:indexes" minOccurs="0"/>
<xs:element name="unique-constraints" type="orm:unique-constraints" minOccurs="0"/>
<xs:element name="discriminator-column" type="orm:discriminator-column" minOccurs="0"/>
<xs:element name="discriminator-map" type="orm:discriminator-map" minOccurs="0"/>
<xs:element name="lifecycle-callbacks" type="orm:lifecycle-callbacks" minOccurs="0" maxOccurs="1" />
<xs:element name="entity-listeners" type="orm:entity-listeners" minOccurs="0" maxOccurs="1" />
<xs:element name="named-queries" type="orm:named-queries" minOccurs="0" maxOccurs="1" />
<xs:element name="named-native-queries" type="orm:named-native-queries" minOccurs="0" maxOccurs="1" />
<xs:element name="sql-result-set-mappings" type="orm:sql-result-set-mappings" minOccurs="0" maxOccurs="unbounded" />
<xs:element name="id" type="orm:id" minOccurs="0" maxOccurs="unbounded" />
<xs:element name="field" type="orm:field" minOccurs="0" maxOccurs="unbounded"/>
<xs:element name="embedded" type="orm:embedded" minOccurs="0" maxOccurs="unbounded"/>
<xs:element name="one-to-one" type="orm:one-to-one" minOccurs="0" maxOccurs="unbounded"/>
<xs:element name="one-to-many" type="orm:one-to-many" minOccurs="0" maxOccurs="unbounded" />
<xs:element name="many-to-one" type="orm:many-to-one" minOccurs="0" maxOccurs="unbounded" />
<xs:element name="many-to-many" type="orm:many-to-many" minOccurs="0" maxOccurs="unbounded" />
<xs:element name="association-overrides" type="orm:association-overrides" minOccurs="0" maxOccurs="unbounded" />
<xs:element name="attribute-overrides" type="orm:attribute-overrides" minOccurs="0" maxOccurs="unbounded" />
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="name" type="xs:string" use="required" />
<xs:attribute name="table" type="orm:tablename" />
<xs:attribute name="schema" type="xs:NMTOKEN" />
<xs:attribute name="repository-class" type="orm:fqcn"/>
<xs:attribute name="inheritance-type" type="orm:inheritance-type"/>
<xs:attribute name="change-tracking-policy" type="orm:change-tracking-policy" />
<xs:attribute name="read-only" type="xs:boolean" default="false" />
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:simpleType name="tablename" id="tablename">
<xs:restriction base="xs:token">
<xs:pattern value="[a-zA-Z_u01-uff.]+" id="tablename.pattern">
</xs:pattern>
</xs:restriction>
</xs:simpleType>
<xs:complexType name="option" mixed="true">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="option" type="orm:option"/>
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="name" type="xs:NMTOKEN" use="required"/>
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="options">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="option" type="orm:option" minOccurs="0" maxOccurs="unbounded"/>
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="mapped-superclass" >
<xs:complexContent>
<xs:extension base="orm:entity"/>
</xs:complexContent>
</xs:complexType>
<xs:complexType name="embeddable">
<xs:complexContent>
<xs:extension base="orm:entity"/>
</xs:complexContent>
</xs:complexType>
<xs:simpleType name="change-tracking-policy">
<xs:restriction base="xs:token">
<xs:enumeration value="DEFERRED_IMPLICIT"/>
<xs:enumeration value="DEFERRED_EXPLICIT"/>
<xs:enumeration value="NOTIFY"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="inheritance-type">
<xs:restriction base="xs:token">
<xs:enumeration value="SINGLE_TABLE"/>
<xs:enumeration value="JOINED"/>
<xs:enumeration value="TABLE_PER_CLASS"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="generator-strategy">
<xs:restriction base="xs:token">
<xs:enumeration value="NONE"/>
<xs:enumeration value="SEQUENCE"/>
<xs:enumeration value="IDENTITY"/>
<xs:enumeration value="AUTO"/>
<xs:enumeration value="UUID"/>
<xs:enumeration value="CUSTOM" />
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="fk-action">
<xs:restriction base="xs:token">
<xs:enumeration value="CASCADE"/>
<xs:enumeration value="RESTRICT"/>
<xs:enumeration value="SET NULL"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="fetch-type">
<xs:restriction base="xs:token">
<xs:enumeration value="EAGER"/>
<xs:enumeration value="LAZY"/>
<xs:enumeration value="EXTRA_LAZY"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="generated-type">
<xs:restriction base="xs:token">
<xs:enumeration value="NEVER"/>
<xs:enumeration value="INSERT"/>
<xs:enumeration value="ALWAYS"/>
</xs:restriction>
</xs:simpleType>
<xs:complexType name="field">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="options" type="orm:options" minOccurs="0" />
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="name" type="xs:NMTOKEN" use="required" />
<xs:attribute name="type" type="orm:type" default="string" />
<xs:attribute name="column" type="orm:columntoken" />
<xs:attribute name="length" type="xs:NMTOKEN" />
<xs:attribute name="unique" type="xs:boolean" default="false" />
<xs:attribute name="nullable" type="xs:boolean" default="false" />
<xs:attribute name="insertable" type="xs:boolean" default="true" />
<xs:attribute name="updatable" type="xs:boolean" default="true" />
<xs:attribute name="generated" type="orm:generated-type" default="NEVER" />
<xs:attribute name="enum-type" type="xs:string" />
<xs:attribute name="version" type="xs:boolean" />
<xs:attribute name="column-definition" type="xs:string" />
<xs:attribute name="precision" type="xs:integer" use="optional" />
<xs:attribute name="scale" type="xs:integer" use="optional" />
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="embedded">
<xs:sequence>
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:sequence>
<xs:attribute name="name" type="xs:string" use="required" />
<xs:attribute name="class" type="orm:fqcn" use="optional" />
<xs:attribute name="column-prefix" type="xs:string" use="optional" />
<xs:attribute name="use-column-prefix" type="xs:boolean" default="true" use="optional" />
</xs:complexType>
<xs:complexType name="discriminator-column">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="options" type="orm:options" minOccurs="0" />
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="name" type="xs:NMTOKEN" use="required" />
<xs:attribute name="type" type="xs:NMTOKEN"/>
<xs:attribute name="field-name" type="xs:NMTOKEN" />
<xs:attribute name="length" type="xs:NMTOKEN" />
<xs:attribute name="column-definition" type="xs:string" />
<xs:attribute name="enum-type" type="xs:string" />
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="unique-constraint">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="options" type="orm:options" minOccurs="0" />
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="name" type="xs:NMTOKEN" use="optional"/>
<xs:attribute name="columns" type="xs:string" use="optional"/>
<xs:attribute name="fields" type="xs:string" use="optional"/>
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="unique-constraints">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="unique-constraint" type="orm:unique-constraint" minOccurs="1" maxOccurs="unbounded"/>
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="index">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="options" type="orm:options" minOccurs="0" />
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="name" type="xs:NMTOKEN" use="optional"/>
<xs:attribute name="columns" type="xs:string" use="optional"/>
<xs:attribute name="fields" type="xs:string" use="optional"/>
<xs:attribute name="flags" type="xs:string" use="optional"/>
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="indexes">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="index" type="orm:index" minOccurs="1" maxOccurs="unbounded"/>
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="discriminator-mapping">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="value" type="orm:type" use="required"/>
<xs:attribute name="class" type="orm:fqcn" use="required"/>
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="discriminator-map">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="discriminator-mapping" type="orm:discriminator-mapping" minOccurs="1" maxOccurs="unbounded"/>
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="generator">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="strategy" type="orm:generator-strategy" use="optional" default="AUTO" />
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="id">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="generator" type="orm:generator" minOccurs="0" />
<xs:element name="sequence-generator" type="orm:sequence-generator" minOccurs="0" maxOccurs="1" />
<xs:element name="custom-id-generator" type="orm:custom-id-generator" minOccurs="0" maxOccurs="1" />
<xs:element name="options" type="orm:options" minOccurs="0" />
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="name" type="xs:NMTOKEN" use="required" />
<xs:attribute name="type" type="orm:type" />
<xs:attribute name="column" type="orm:columntoken" />
<xs:attribute name="length" type="xs:NMTOKEN" />
<xs:attribute name="association-key" type="xs:boolean" default="false" />
<xs:attribute name="column-definition" type="xs:string" />
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="sequence-generator">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="sequence-name" type="xs:NMTOKEN" use="required" />
<xs:attribute name="allocation-size" type="xs:integer" use="optional" default="1" />
<xs:attribute name="initial-value" type="xs:integer" use="optional" default="1" />
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="custom-id-generator">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="class" type="orm:fqcn" use="required" />
</xs:complexType>
<xs:simpleType name="fqcn" id="fqcn">
<xs:restriction base="xs:token">
<xs:pattern value="[a-zA-Z_u01-uff][a-zA-Z0-9_u01-uff]+" id="fqcn.pattern">
</xs:pattern>
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="type" id="type">
<xs:restriction base="xs:token">
<xs:pattern value="([a-zA-Z_u01-uff][a-zA-Z0-9_u01-uff]+)|(\c+)" id="type.class.pattern">
</xs:pattern>
</xs:restriction>
</xs:simpleType>
<xs:complexType name="inverse-join-columns">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="join-column" type="orm:join-column" minOccurs="1" maxOccurs="unbounded" />
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="join-column">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="name" type="xs:NMTOKEN" use="optional" />
<xs:attribute name="referenced-column-name" type="xs:NMTOKEN" use="optional" default="id" />
<xs:attribute name="unique" type="xs:boolean" default="false" />
<xs:attribute name="nullable" type="xs:boolean" default="true" />
<xs:attribute name="on-delete" type="orm:fk-action" />
<xs:attribute name="column-definition" type="xs:string" />
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="join-columns">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="join-column" type="orm:join-column" minOccurs="1" maxOccurs="unbounded" />
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="join-table">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="join-columns" type="orm:join-columns" />
<xs:element name="inverse-join-columns" type="orm:join-columns" />
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="name" type="xs:NMTOKEN" use="required" />
<xs:attribute name="schema" type="xs:NMTOKEN" />
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="order-by">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="order-by-field" type="orm:order-by-field" minOccurs="1" maxOccurs="unbounded" />
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="order-by-field">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="name" type="xs:NMTOKEN" use="required" />
<xs:attribute name="direction" type="orm:order-by-direction" default="ASC" />
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:simpleType name="order-by-direction">
<xs:restriction base="xs:token">
<xs:enumeration value="ASC"/>
<xs:enumeration value="DESC"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="columntoken" id="columntoken">
<xs:restriction base="xs:token">
<xs:pattern value="[-._:A-Za-z0-9`]+" id="columntoken.pattern"/>
</xs:restriction>
</xs:simpleType>
<xs:complexType name="many-to-many">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="cache" type="orm:cache" minOccurs="0" maxOccurs="1"/>
<xs:element name="cascade" type="orm:cascade-type" minOccurs="0" />
<xs:element name="join-table" type="orm:join-table" minOccurs="0" />
<xs:element name="order-by" type="orm:order-by" minOccurs="0" />
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="field" type="xs:NMTOKEN" use="required" />
<xs:attribute name="target-entity" type="xs:string" use="required" />
<xs:attribute name="mapped-by" type="xs:NMTOKEN" />
<xs:attribute name="inversed-by" type="xs:NMTOKEN" />
<xs:attribute name="index-by" type="xs:NMTOKEN" />
<xs:attribute name="fetch" type="orm:fetch-type" default="LAZY" />
<xs:attribute name="orphan-removal" type="xs:boolean" default="false" />
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="one-to-many">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="cache" type="orm:cache" minOccurs="0" maxOccurs="1"/>
<xs:element name="cascade" type="orm:cascade-type" minOccurs="0" />
<xs:element name="order-by" type="orm:order-by" minOccurs="0" />
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="field" type="xs:NMTOKEN" use="required" />
<xs:attribute name="target-entity" type="xs:string" use="required" />
<xs:attribute name="mapped-by" type="xs:NMTOKEN" use="required" />
<xs:attribute name="index-by" type="xs:NMTOKEN" />
<xs:attribute name="fetch" type="orm:fetch-type" default="LAZY" />
<xs:attribute name="orphan-removal" type="xs:boolean" default="false" />
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="many-to-one">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="cache" type="orm:cache" minOccurs="0" maxOccurs="1"/>
<xs:element name="cascade" type="orm:cascade-type" minOccurs="0" />
<xs:choice minOccurs="0" maxOccurs="1">
<xs:element name="join-column" type="orm:join-column"/>
<xs:element name="join-columns" type="orm:join-columns"/>
</xs:choice>
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="field" type="xs:NMTOKEN" use="required" />
<xs:attribute name="target-entity" type="xs:string" />
<xs:attribute name="inversed-by" type="xs:NMTOKEN" />
<xs:attribute name="fetch" type="orm:fetch-type" default="LAZY" />
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="one-to-one">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="cache" type="orm:cache" minOccurs="0" maxOccurs="1"/>
<xs:element name="cascade" type="orm:cascade-type" minOccurs="0" />
<xs:choice minOccurs="0" maxOccurs="1">
<xs:element name="join-column" type="orm:join-column"/>
<xs:element name="join-columns" type="orm:join-columns"/>
</xs:choice>
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="field" type="xs:NMTOKEN" use="required" />
<xs:attribute name="target-entity" type="xs:string" />
<xs:attribute name="mapped-by" type="xs:NMTOKEN" />
<xs:attribute name="inversed-by" type="xs:NMTOKEN" />
<xs:attribute name="fetch" type="orm:fetch-type" default="LAZY" />
<xs:attribute name="orphan-removal" type="xs:boolean" default="false" />
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
<xs:complexType name="association-overrides">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="association-override" type="orm:association-override" minOccurs="1" maxOccurs="unbounded" />
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
</xs:complexType>
<xs:complexType name="association-override">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="join-table" type="orm:join-table" minOccurs="0" />
<xs:element name="join-columns" type="orm:join-columns" minOccurs="0" />
<xs:element name="inversed-by" type="orm:inversed-by-override" minOccurs="0" maxOccurs="1" />
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="name" type="xs:NMTOKEN" use="required" />
<xs:attribute name="fetch" type="orm:fetch-type" use="optional" />
</xs:complexType>
<xs:complexType name="inversed-by-override">
<xs:attribute name="name" type="xs:NMTOKEN" use="required" />
</xs:complexType>
<xs:complexType name="attribute-overrides">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="attribute-override" type="orm:attribute-override" minOccurs="1" maxOccurs="unbounded" />
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
</xs:complexType>
<xs:complexType name="attribute-override">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="field" type="orm:attribute-override-field" minOccurs="1" />
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="name" type="xs:NMTOKEN" use="required" />
</xs:complexType>
<xs:complexType name="attribute-override-field">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element name="options" type="orm:options" minOccurs="0" />
<xs:any minOccurs="0" maxOccurs="unbounded" namespace="##other"/>
</xs:choice>
<xs:attribute name="type" type="orm:type" default="string" />
<xs:attribute name="column" type="orm:columntoken" />
<xs:attribute name="length" type="xs:NMTOKEN" />
<xs:attribute name="unique" type="xs:boolean" default="false" />
<xs:attribute name="nullable" type="xs:boolean" default="false" />
<xs:attribute name="insertable" type="xs:boolean" default="true" />
<xs:attribute name="updateable" type="xs:boolean" default="true" />
<xs:attribute name="version" type="xs:boolean" />
<xs:attribute name="column-definition" type="xs:string" />
<xs:attribute name="precision" type="xs:integer" use="optional" />
<xs:attribute name="scale" type="xs:integer" use="optional" />
<xs:anyAttribute namespace="##other"/>
</xs:complexType>
</xs:schema>
-1
Переглянути файл
@@ -26,7 +26,6 @@ pub(crate) mod jvm_inspect;
mod move_refactoring;
pub(crate) mod reserved_names;
mod signature;
pub(crate) mod stream_trace;
pub use formatter::configure_formatter;
/// First start imports the Maven / Gradle model, which can take minutes.
const READY_TIMEOUT: Duration = Duration::from_secs(240);
+3 -8
Переглянути файл
@@ -63,7 +63,7 @@ impl JdtJvmInspector {
}
/// `VmTarget` is not `Serialize`: the field names here are the bundle's.
pub(super) fn target_json(target: &VmTarget) -> Value {
fn target_json(target: &VmTarget) -> Value {
json!({
"pid": target.pid,
"host": target.attach_host,
@@ -72,7 +72,7 @@ pub(super) fn target_json(target: &VmTarget) -> Value {
})
}
pub(super) fn command_error(e: IdeError) -> InspectError {
fn command_error(e: IdeError) -> InspectError {
if missing_bundle(&e) {
InspectError::Unsupported("the JVM inspector bundle is not loaded".to_owned())
} else {
@@ -81,7 +81,7 @@ pub(super) fn command_error(e: IdeError) -> InspectError {
}
/// `{"ok": payload}` or `{"error": code, "detail": text}`.
pub(super) fn decode<T: DeserializeOwned>(mut reply: Value) -> Result<T, InspectError> {
fn decode<T: DeserializeOwned>(mut reply: Value) -> Result<T, InspectError> {
if let Some(code) = reply.get("error").and_then(Value::as_str) {
let detail = reply.get("detail").and_then(Value::as_str);
return Err(match code {
@@ -94,11 +94,6 @@ pub(super) fn decode<T: DeserializeOwned>(mut reply: Value) -> Result<T, Inspect
"classNotLoaded" => InspectError::ClassNotLoaded,
"notSuspended" => InspectError::NotSuspended,
"timedOut" => InspectError::TimedOut,
"noSession" => InspectError::NoSession,
"notAtChainStart" => InspectError::NotAtChainStart(detail.unwrap_or_default().to_owned()),
"busy" => InspectError::Busy,
"noTrace" => InspectError::NoTrace,
"failed" | "badArgument" => InspectError::Failed(detail.unwrap_or(code).to_owned()),
other => InspectError::Failed(match detail {
Some(detail) => format!("{other}: {detail}"),
None => other.to_owned(),
-246
Переглянути файл
@@ -1,246 +0,0 @@
//! [`StreamTracer`] over the `openidea.jvm.stream.*` commands of the JVM inspector bundle that runs
//! inside jdtls (`java/jvm-inspect`).
use super::jvm_inspect::{command_error, decode, target_json};
use crate::LspManager;
use ide_jvm_inspect::{
AbortState, CollectedTerminal, InspectError, InspectFuture, JvmValue, StreamTracer, TraceCollected, TraceId,
TraceState, VmTarget,
};
use serde::Deserialize;
use serde::de::DeserializeOwned;
use serde_json::{Value, json};
use std::path::PathBuf;
use std::sync::Arc;
use std::time::Duration;
use tokio::time::timeout;
/// `wait` is held by the bundle for the `ms` it is given; the command times out this long after.
const WAIT_SLACK: Duration = Duration::from_secs(10);
const ABORT_TIMEOUT: Duration = Duration::from_secs(15);
const COMMAND_TIMEOUT: Duration = Duration::from_secs(15);
/// Each record is previewed with at least one JDWP round trip (about 0.1 ms locally, far more
/// over a remote attach).
fn collect_timeout(records: u64) -> Duration {
Duration::from_secs(60)
.saturating_add(Duration::from_millis(5).saturating_mul(records.try_into().unwrap_or(u32::MAX)))
}
pub struct JdtStreamTracer {
lsp: Arc<LspManager>,
/// A path inside the module whose jdtls runs the debug session.
server: PathBuf,
}
impl JdtStreamTracer {
/// Deliberately without `JdtJvmInspector`'s turn: a `wait` that holds a JDT LS thread for
/// seconds must not keep the memory view from reading while the trace runs.
pub fn new(lsp: Arc<LspManager>, server: PathBuf) -> Self {
Self { lsp, server }
}
async fn call<T: DeserializeOwned>(
&self,
op: &str,
target: &VmTarget,
args: Value,
limit: Duration,
) -> Result<T, InspectError> {
let command = format!("openidea.jvm.stream.{op}");
let arguments = vec![target_json(target), args];
let reply = timeout(limit, self.lsp.jdtls_command(&self.server, &command, arguments))
.await
.map_err(|_| InspectError::TimedOut)?
.map_err(command_error)?;
decode(reply)
}
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct Armed {
trace_id: TraceId,
}
#[derive(Deserialize)]
#[serde(tag = "state", rename_all = "camelCase", rename_all_fields = "camelCase")]
enum WireState {
Running {
records: u64,
dropped: u64,
elapsed_ms: u64,
},
Parked {
records: u64,
dropped: u64,
},
Failed {
#[serde(default)]
detail: String,
},
Cancelled {
#[serde(default)]
detail: String,
},
}
impl From<WireState> for TraceState {
fn from(state: WireState) -> Self {
match state {
WireState::Running { records, dropped, elapsed_ms } => Self::Running { records, dropped, elapsed_ms },
WireState::Parked { records, dropped } => Self::Parked { records, dropped },
WireState::Failed { detail } => Self::Failed { detail },
WireState::Cancelled { detail } => Self::Cancelled { detail },
}
}
}
#[derive(Deserialize)]
struct Stopped {
records: u64,
}
#[derive(Deserialize)]
#[serde(tag = "state", rename_all = "camelCase")]
enum WireAbort {
Interrupted,
Stopped,
Stuck {
#[serde(default)]
holders: Vec<Holder>,
},
Cancelled,
Finished,
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct Holder {
thread_id: i64,
name: String,
}
impl From<WireAbort> for AbortState {
fn from(state: WireAbort) -> Self {
match state {
WireAbort::Interrupted => Self::Interrupted,
WireAbort::Stopped => Self::Stopped,
WireAbort::Stuck { holders } => {
Self::Stuck { holders: holders.into_iter().map(|h| (h.thread_id, h.name)).collect() }
}
WireAbort::Cancelled => Self::Cancelled,
WireAbort::Finished => Self::Finished,
}
}
}
#[derive(Deserialize)]
#[serde(rename_all = "camelCase")]
struct WireCollected {
records: Vec<WireRecord>,
dropped: u64,
terminal: WireTerminal,
skipped_breakpoints: u32,
sequentialized: bool,
}
#[derive(Deserialize)]
struct WireRecord {
step: u16,
value: JvmValue,
}
#[derive(Deserialize)]
#[serde(tag = "kind", rename_all = "camelCase")]
enum WireTerminal {
Value { value: JvmValue },
Void,
Threw { exception: JvmValue },
}
impl From<WireCollected> for TraceCollected {
fn from(wire: WireCollected) -> Self {
Self {
records: wire.records.into_iter().map(|r| (r.step, r.value)).collect(),
dropped: wire.dropped,
terminal: match wire.terminal {
WireTerminal::Value { value } => CollectedTerminal::Value(value),
WireTerminal::Void => CollectedTerminal::Void,
WireTerminal::Threw { exception } => CollectedTerminal::Threw(exception),
},
skipped_breakpoints: wire.skipped_breakpoints,
sequentialized: wire.sequentialized,
}
}
}
impl StreamTracer for JdtStreamTracer {
fn arm<'a>(
&'a self,
target: &'a VmTarget,
thread_id: i64,
plan: &'a Value,
budget: u32,
token: &'a str,
) -> InspectFuture<'a, TraceId> {
Box::pin(async move {
let args = json!({"threadId": thread_id, "plan": plan, "budget": budget, "token": token});
Ok(self.call::<Armed>("arm", target, args, COMMAND_TIMEOUT).await?.trace_id)
})
}
fn wait<'a>(&'a self, target: &'a VmTarget, trace: TraceId, ms: u32) -> InspectFuture<'a, TraceState> {
Box::pin(async move {
let limit = Duration::from_millis(u64::from(ms)) + WAIT_SLACK;
let state: WireState = self.call("wait", target, json!({"traceId": trace, "ms": ms}), limit).await?;
Ok(state.into())
})
}
fn stop<'a>(&'a self, target: &'a VmTarget, trace: TraceId) -> InspectFuture<'a, u64> {
Box::pin(async move {
Ok(self.call::<Stopped>("stop", target, json!({"traceId": trace}), COMMAND_TIMEOUT).await?.records)
})
}
fn abort<'a>(&'a self, target: &'a VmTarget, trace: TraceId) -> InspectFuture<'a, AbortState> {
Box::pin(async move {
let state: WireAbort = self.call("abort", target, json!({"traceId": trace}), ABORT_TIMEOUT).await?;
Ok(state.into())
})
}
fn collect<'a>(&'a self, target: &'a VmTarget, trace: TraceId, records: u64) -> InspectFuture<'a, TraceCollected> {
Box::pin(async move {
let limit = collect_timeout(records);
let collected: WireCollected = self.call("collect", target, json!({"traceId": trace}), limit).await?;
Ok(collected.into())
})
}
fn release<'a>(&'a self, target: &'a VmTarget, trace: TraceId) -> InspectFuture<'a, ()> {
Box::pin(async move {
self.call::<Value>("release", target, json!({"traceId": trace}), COMMAND_TIMEOUT).await.map(drop)
})
}
fn release_armed<'a>(&'a self, target: &'a VmTarget, token: &'a str) -> InspectFuture<'a, ()> {
Box::pin(async move {
// Waits for an arm still setting up: as long as an arm may take.
self.call::<Value>("release", target, json!({"token": token}), COMMAND_TIMEOUT).await.map(drop)
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn collect_timeout_grows_with_the_records() {
assert_eq!(collect_timeout(0), Duration::from_secs(60));
assert_eq!(collect_timeout(50_000), Duration::from_secs(60 + 250));
assert!(collect_timeout(u64::MAX) >= collect_timeout(50_000));
}
}
-5
Переглянути файл
@@ -40,12 +40,10 @@ mod uri;
mod virtual_doc;
mod vue_navigation;
mod vue_refs;
mod xml_catalog;
pub use injections::{InjectedRange, InjectionProvider, MAX_INJECTED_DOCUMENT_BYTES};
pub use inspect::{CheckedServer, DocumentCheck, FileInspection, InspectHost, InspectOptions};
pub use jdtls::jvm_inspect::JdtJvmInspector;
pub use jdtls::stream_trace::JdtStreamTracer;
pub use kotlin_lsp::{KotlinDebugServer, KotlinDebugUnavailable};
pub use launch::{LaunchError, Launcher, ProcessLauncher};
pub use notebook::{NotebookCell, NotebookCellDoc, cell_uri};
@@ -3796,9 +3794,6 @@ impl LspManager {
if cfg.name == compose::SERVER {
compose::configure_yaml_compose_schemas(&mut cfg, &self.open_compose_files());
}
if cfg.name == xml_catalog::SERVER {
xml_catalog::configure_lemminx_catalogs(&mut cfg);
}
cfg
}
-149
Переглянути файл
@@ -1,149 +0,0 @@
//! Bundled XML catalogs for LemMinX so known-broken remote XSDs resolve locally.
//!
//! Doctrine's hosted `doctrine-mapping.xsd` advertises the wrong `targetNamespace`
//! (the schema URL itself) after an http→https rewrite, so any mapping file that
//! points `xsi:schemaLocation` at that URL fails with `TargetNamespace.1` /
//! `cvc-elt.1.a`. An OASIS catalog maps the namespace and those system IDs to the
//! correct upstream schema we ship.
use ide_language::LanguageServerConfig;
use serde_json::{Value, json};
use std::path::{Path, PathBuf};
pub const SERVER: &str = "lemminx";
const DOCTRINE_XSD: &str = include_str!("../schemas/xml/doctrine-mapping.xsd");
const CATALOG_TEMPLATE: &str = r#"<?xml version="1.0" encoding="UTF-8"?>
<catalog xmlns="urn:oasis:names:tc:entity:xmlns:xml:catalog">
<uri name="http://doctrine-project.org/schemas/orm/doctrine-mapping" uri="doctrine-mapping.xsd"/>
<uri name="https://www.doctrine-project.org/schemas/orm/doctrine-mapping.xsd" uri="doctrine-mapping.xsd"/>
<system systemId="https://www.doctrine-project.org/schemas/orm/doctrine-mapping.xsd" uri="doctrine-mapping.xsd"/>
<system systemId="http://www.doctrine-project.org/schemas/orm/doctrine-mapping.xsd" uri="doctrine-mapping.xsd"/>
</catalog>
"#;
/// Writes the bundled catalog (idempotent) and prepends it to LemMinX `xml.catalogs`.
pub fn configure_lemminx_catalogs(cfg: &mut LanguageServerConfig) {
if cfg.name != SERVER {
return;
}
let Some(catalog) = ensure_catalog() else { return };
let catalog = path_for_settings(&catalog);
let mut settings = cfg.settings.take().filter(Value::is_object).unwrap_or_else(|| json!({}));
let Some(root) = settings.as_object_mut() else {
cfg.settings = Some(settings);
return;
};
let Some(xml) = root.entry("xml").or_insert_with(|| json!({})).as_object_mut() else {
cfg.settings = Some(settings);
return;
};
let Some(catalogs) = xml.entry("catalogs").or_insert_with(|| json!([])).as_array_mut() else {
cfg.settings = Some(settings);
return;
};
if catalogs.iter().any(|v| v.as_str() == Some(catalog.as_str())) {
cfg.settings = Some(settings);
return;
}
catalogs.insert(0, Value::String(catalog));
cfg.settings = Some(settings);
}
fn ensure_catalog() -> Option<PathBuf> {
// Per-pid directory: shared `/tmp/openidea-xml-catalog` would let another
// local user plant a catalog that remaps arbitrary schema URIs.
let dir = std::env::temp_dir().join(format!("openidea-xml-catalog-{}", std::process::id()));
if let Err(e) = ide_vfs::create_private_dir(&dir) {
tracing::warn!("xml catalog: cannot create {}: {e}", dir.display());
return None;
}
let xsd = dir.join("doctrine-mapping.xsd");
if !write_if_changed(&xsd, DOCTRINE_XSD.as_bytes()) {
tracing::warn!("xml catalog: cannot write {}", xsd.display());
return None;
}
let catalog = dir.join("catalog.xml");
if !write_if_changed(&catalog, CATALOG_TEMPLATE.as_bytes()) {
tracing::warn!("xml catalog: cannot write {}", catalog.display());
return None;
}
Some(catalog)
}
fn write_if_changed(path: &Path, bytes: &[u8]) -> bool {
if std::fs::read(path).ok().as_deref() == Some(bytes) {
return true;
}
ide_vfs::write_atomic_private(path, bytes).is_ok()
}
fn path_for_settings(path: &Path) -> String {
path.to_string_lossy().replace('\\', "/")
}
#[cfg(test)]
mod tests {
use super::*;
use ide_language::LanguageRegistry;
const DOCTRINE_NS: &str = "http://doctrine-project.org/schemas/orm/doctrine-mapping";
const DOCTRINE_SCHEMA_HTTPS: &str = "https://www.doctrine-project.org/schemas/orm/doctrine-mapping.xsd";
const DOCTRINE_SCHEMA_HTTP: &str = "http://www.doctrine-project.org/schemas/orm/doctrine-mapping.xsd";
#[test]
fn bundled_xsd_keeps_http_namespace() {
assert!(DOCTRINE_XSD.contains(&format!("targetNamespace=\"{DOCTRINE_NS}\"")));
assert!(!DOCTRINE_XSD.contains("xmlns:xs=\"https://www.w3.org/2001/XMLSchema\""));
assert!(!DOCTRINE_XSD.contains("targetNamespace=\"https://www.doctrine-project.org"));
}
#[test]
fn catalog_maps_namespace_and_system_ids() {
assert!(CATALOG_TEMPLATE.contains(&format!(r#"name="{DOCTRINE_NS}""#)));
assert!(CATALOG_TEMPLATE.contains(&format!(r#"name="{DOCTRINE_SCHEMA_HTTPS}""#)));
assert!(CATALOG_TEMPLATE.contains(&format!(r#"systemId="{DOCTRINE_SCHEMA_HTTPS}""#)));
assert!(CATALOG_TEMPLATE.contains(&format!(r#"systemId="{DOCTRINE_SCHEMA_HTTP}""#)));
assert_eq!(CATALOG_TEMPLATE.matches(r#"uri="doctrine-mapping.xsd""#).count(), 4);
}
#[test]
fn prepends_catalog_without_dropping_user_entries() {
let reg = LanguageRegistry::load(None).unwrap();
let xml = reg.get(&ide_core::LanguageId::new("xml")).unwrap();
let mut cfg = xml.language_servers[0].clone();
cfg.settings = Some(json!({"xml": {"catalogs": ["/user/catalog.xml"]}}));
configure_lemminx_catalogs(&mut cfg);
let list: Vec<String> = cfg.settings.as_ref().unwrap()["xml"]["catalogs"]
.as_array()
.unwrap()
.iter()
.filter_map(Value::as_str)
.map(str::to_owned)
.collect();
assert_eq!(list.len(), 2);
assert!(list[0].ends_with("catalog.xml"));
assert!(list[0].contains(&format!("openidea-xml-catalog-{}", std::process::id())));
assert_eq!(list[1], "/user/catalog.xml");
configure_lemminx_catalogs(&mut cfg);
assert_eq!(cfg.settings.as_ref().unwrap()["xml"]["catalogs"].as_array().unwrap().len(), 2);
let catalog = PathBuf::from(&list[0]);
let body = std::fs::read_to_string(&catalog).unwrap();
assert_eq!(body, CATALOG_TEMPLATE);
assert!(body.contains(&format!(r#"name="{DOCTRINE_NS}""#)));
let xsd = catalog.with_file_name("doctrine-mapping.xsd");
assert_eq!(std::fs::read_to_string(xsd).unwrap(), DOCTRINE_XSD);
}
#[test]
fn ignores_other_servers() {
let reg = LanguageRegistry::load(None).unwrap();
let yaml = reg.get(&ide_core::LanguageId::new("yaml")).unwrap();
let mut cfg = yaml.language_servers[0].clone();
let before = cfg.settings.clone();
configure_lemminx_catalogs(&mut cfg);
assert_eq!(cfg.settings, before);
}
}
-223
Переглянути файл
@@ -324,7 +324,6 @@ fn harness_languages(languages: &[MockLanguage<'_>], adjust: impl Fn(&mut Langua
framework_files: Vec::new(),
formatter: None,
scratch_template: None,
rainbow_brackets: Default::default(),
tree_sitter: None,
language_servers: servers
.iter()
@@ -3171,228 +3170,6 @@ async fn jvm_inspect_sends_one_command_at_a_time() {
assert_eq!(most.load(Ordering::SeqCst), 1);
}
async fn stream_harness() -> (Harness, Arc<MockState>, ide_lsp::JdtStreamTracer) {
let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);
let (_, path) = h.open("Sample.java", "class Sample {}");
h.wait_status("jdtls", ServerStatus::Ready).await;
let tracer = ide_lsp::JdtStreamTracer::new(h.mgr.clone(), path);
let state = h.launcher.state("jdtls");
(h, state, tracer)
}
fn stream_launch_target() -> ide_jvm_inspect::VmTarget {
ide_jvm_inspect::VmTarget { pid: Some(42), attach_host: None, attach_port: None, generation: 3 }
}
#[tokio::test(flavor = "multi_thread")]
async fn stream_commands_send_target_then_named_fields() {
use ide_jvm_inspect::StreamTracer;
let (_h, s, tracer) = stream_harness().await;
let target = stream_launch_target();
let target_json = json!({"pid": 42, "host": null, "port": null, "generation": 3});
let plan = json!({"root": {"line": 14}});
s.respond("workspace/executeCommand", json!({"ok": {"traceId": 3}}));
assert_eq!(tracer.arm(&target, 7, &plan, 500, "t1").await.unwrap(), 3);
s.respond(
"workspace/executeCommand",
json!({"ok": {"state": "running", "records": 1, "dropped": 0, "elapsedMs": 2}}),
);
tracer.wait(&target, 3, 250).await.unwrap();
s.respond("workspace/executeCommand", json!({"ok": {"records": 9}}));
assert_eq!(tracer.stop(&target, 3).await.unwrap(), 9);
s.respond("workspace/executeCommand", json!({"ok": {"state": "stopped"}}));
tracer.abort(&target, 3).await.unwrap();
s.respond(
"workspace/executeCommand",
json!({"ok": {"records": [], "dropped": 0, "terminal": {"kind": "void"}, "skippedBreakpoints": 0,
"sequentialized": false}}),
);
tracer.collect(&target, 3, 2).await.unwrap();
s.respond("workspace/executeCommand", json!({"ok": {}}));
tracer.release(&target, 3).await.unwrap();
s.respond("workspace/executeCommand", json!({"ok": {}}));
tracer.release_armed(&target, "t1").await.unwrap();
let asked = s.requested("workspace/executeCommand");
let seen: Vec<_> = asked.iter().map(|p| (p["command"].clone(), p["arguments"].clone())).collect();
assert_eq!(
seen,
vec![
(
json!("openidea.jvm.stream.arm"),
json!([target_json, {"threadId": 7, "plan": plan, "budget": 500, "token": "t1"}])
),
(json!("openidea.jvm.stream.wait"), json!([target_json, {"traceId": 3, "ms": 250}])),
(json!("openidea.jvm.stream.stop"), json!([target_json, {"traceId": 3}])),
(json!("openidea.jvm.stream.abort"), json!([target_json, {"traceId": 3}])),
(json!("openidea.jvm.stream.collect"), json!([target_json, {"traceId": 3}])),
(json!("openidea.jvm.stream.release"), json!([target_json, {"traceId": 3}])),
(json!("openidea.jvm.stream.release"), json!([target_json, {"token": "t1"}])),
]
);
}
#[tokio::test(flavor = "multi_thread")]
async fn stream_wait_decodes_states() {
use ide_jvm_inspect::{StreamTracer, TraceState};
let (_h, s, tracer) = stream_harness().await;
let target = stream_launch_target();
let cases = [
(
json!({"state": "running", "records": 10, "dropped": 0, "elapsedMs": 5}),
TraceState::Running { records: 10, dropped: 0, elapsed_ms: 5 },
),
(
json!({"state": "parked", "records": 50000, "dropped": 950000, "elapsedMs": 96}),
TraceState::Parked { records: 50000, dropped: 950000 },
),
(
json!({"state": "failed", "records": 4, "dropped": 0, "elapsedMs": 12, "detail": "missed map"}),
TraceState::Failed { detail: "missed map".into() },
),
(
json!({"state": "cancelled", "records": 0, "dropped": 0, "elapsedMs": 12,
"detail": "cancelled before the terminal ran"}),
TraceState::Cancelled { detail: "cancelled before the terminal ran".into() },
),
];
for (ok, expected) in cases {
s.respond("workspace/executeCommand", json!({"ok": ok}));
assert_eq!(tracer.wait(&target, 1, 10).await.unwrap(), expected, "{ok}");
}
}
#[tokio::test(flavor = "multi_thread")]
async fn stream_abort_decodes_every_state() {
use ide_jvm_inspect::{AbortState, StreamTracer};
let (_h, s, tracer) = stream_harness().await;
let target = stream_launch_target();
let cases = [
(json!({"state": "interrupted"}), AbortState::Interrupted),
(json!({"state": "stopped"}), AbortState::Stopped),
(
json!({"state": "stuck", "holders": [{"threadId": 42, "name": "worker-1"}]}),
AbortState::Stuck { holders: vec![(42, "worker-1".into())] },
),
(json!({"state": "cancelled"}), AbortState::Cancelled),
(json!({"state": "finished"}), AbortState::Finished),
];
for (ok, expected) in cases {
s.respond("workspace/executeCommand", json!({"ok": ok}));
assert_eq!(tracer.abort(&target, 1).await.unwrap(), expected, "{ok}");
}
}
#[tokio::test(flavor = "multi_thread")]
async fn stream_errors_map() {
use ide_jvm_inspect::{InspectError, StreamTracer};
let (_h, s, tracer) = stream_harness().await;
let target = stream_launch_target();
let cases = [
(
json!({"error": "notAtChainStart", "detail": "line 14 is not where the statement starts"}),
InspectError::NotAtChainStart("line 14 is not where the statement starts".into()),
),
(json!({"error": "busy", "detail": "trace 2 is running"}), InspectError::Busy),
(json!({"error": "noTrace", "detail": "no trace 9 on this VM"}), InspectError::NoTrace),
(json!({"error": "noSession", "detail": "x"}), InspectError::NoSession),
(json!({"error": "stale", "detail": "no thread 77"}), InspectError::Stale),
(json!({"error": "notSuspended", "detail": "thread 1 is running"}), InspectError::NotSuspended),
(json!({"error": "unsupported", "detail": "xs is a List"}), InspectError::Unsupported("xs is a List".into())),
(
json!({"error": "badArgument", "detail": "budget must be 1 or more"}),
InspectError::Failed("budget must be 1 or more".into()),
),
(json!({"error": "failed", "detail": "missed filter"}), InspectError::Failed("missed filter".into())),
(json!({"error": "surprise", "detail": "d"}), InspectError::Failed("surprise: d".into())),
];
for (reply, expected) in cases {
s.respond("workspace/executeCommand", reply.clone());
assert_eq!(tracer.arm(&target, 1, &json!({}), 10, "t").await.unwrap_err(), expected, "{reply}");
}
}
#[tokio::test(flavor = "multi_thread")]
async fn stream_missing_bundle_is_unsupported() {
use ide_jvm_inspect::{InspectError, StreamTracer};
let (_h, s, tracer) = stream_harness().await;
s.errors.lock().insert(
"workspace/executeCommand".into(),
(-32603, "No delegateCommandHandler for openidea.jvm.stream.wait".into()),
);
assert_eq!(
tracer.wait(&stream_launch_target(), 1, 10).await.unwrap_err(),
InspectError::Unsupported("the JVM inspector bundle is not loaded".into())
);
}
#[tokio::test(flavor = "multi_thread")]
async fn stream_collect_decodes() {
use ide_jvm_inspect::{CollectedTerminal, JvmValue, StreamTracer};
let (_h, s, tracer) = stream_harness().await;
let target = stream_launch_target();
s.respond(
"workspace/executeCommand",
json!({"ok": {
"records": [
{"step": 0, "value": {"kind": "boxed", "id": 1, "typeName": "java.lang.Integer", "text": "5"}},
{"step": 1, "value": {"kind": "string", "id": 2, "text": "5", "length": 1}},
],
"dropped": 4,
"terminal": {"kind": "threw",
"exception": {"kind": "object", "id": 9, "typeName": "java.lang.ArithmeticException"}},
"skippedBreakpoints": 1,
"sequentialized": true,
}}),
);
let collected = tracer.collect(&target, 3, 2).await.unwrap();
assert_eq!(
collected.records,
vec![
(0, JvmValue::Boxed { id: 1, type_name: "java.lang.Integer".into(), text: "5".into() }),
(1, JvmValue::Str { id: 2, text: Some("5".into()), length: 1 }),
]
);
assert_eq!(collected.dropped, 4);
assert_eq!(
collected.terminal,
CollectedTerminal::Threw(JvmValue::Object { id: 9, type_name: "java.lang.ArithmeticException".into() })
);
assert_eq!(collected.skipped_breakpoints, 1);
assert!(collected.sequentialized);
s.respond(
"workspace/executeCommand",
json!({"ok": {"records": [], "dropped": 0,
"terminal": {"kind": "value", "value": {"kind": "object", "id": 19, "typeName": "java.util.ArrayList"}},
"skippedBreakpoints": 0, "sequentialized": false}}),
);
assert_eq!(
tracer.collect(&target, 3, 2).await.unwrap().terminal,
CollectedTerminal::Value(JvmValue::Object { id: 19, type_name: "java.util.ArrayList".into() })
);
s.respond(
"workspace/executeCommand",
json!({"ok": {"records": [], "dropped": 0, "terminal": {"kind": "void"},
"skippedBreakpoints": 0, "sequentialized": false}}),
);
assert_eq!(tracer.collect(&target, 3, 2).await.unwrap().terminal, CollectedTerminal::Void);
}
#[tokio::test(flavor = "multi_thread")]
async fn stream_collect_fails_cleanly_on_a_step_beyond_u16() {
use ide_jvm_inspect::{InspectError, StreamTracer};
let (_h, s, tracer) = stream_harness().await;
s.respond(
"workspace/executeCommand",
json!({"ok": {"records": [{"step": 70000, "value": {"kind": "null"}}], "dropped": 0,
"terminal": {"kind": "void"}, "skippedBreakpoints": 0, "sequentialized": false}}),
);
let error = tracer.collect(&stream_launch_target(), 3, 2).await.unwrap_err();
assert!(matches!(error, InspectError::Failed(ref m) if m.contains("malformed")), "{error:?}");
}
#[tokio::test(flavor = "multi_thread")]
async fn debug_server_port_maps_to_module() {
let h = harness_for("java", "java", &[("jdtls", incremental_caps())], &[]);
-1
Переглянути файл
@@ -58,7 +58,6 @@ fn lang(id: &str, ext: &str, server: LanguageServerConfig) -> LanguageConfig {
framework_files: Vec::new(),
formatter: None,
scratch_template: None,
rainbow_brackets: Default::default(),
tree_sitter: None,
language_servers: vec![server],
debugger: None,
-23
Переглянути файл
@@ -38,29 +38,6 @@ pub struct ContentDiff {
pub title: Option<String>,
}
/// A diff opened by a plugin (API 1.10): `None` is a side where the file doesn't exist.
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
pub struct FileDiff {
pub left: Option<String>,
pub right: Option<String>,
pub left_label: Option<String>,
pub right_label: Option<String>,
pub title: Option<String>,
}
impl From<ContentDiff> for FileDiff {
fn from(v: ContentDiff) -> Self {
Self {
left: Some(v.left),
right: Some(v.right),
left_label: v.left_label,
right_label: v.right_label,
title: v.title,
}
}
}
/// ContentTabReply data exchanged with the IDE.
#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize, Type)]
#[serde(rename_all = "camelCase")]
+3 -10
Переглянути файл
@@ -56,7 +56,7 @@ use views_bindings::exports::openidea::plugin::view_provider as wit_view;
use views_bindings::openidea::plugin::view_types as wit_vt;
/// The API version of the world above, `major.minor` of [`host_api`].
pub const API_VERSION: &str = "1.10";
pub const API_VERSION: &str = "1.9";
const EPOCH_TICK: Duration = Duration::from_millis(10);
pub(crate) const MAX_TEXT: usize = 1 << 20;
pub(crate) const MAX_TITLE: usize = 256;
@@ -117,13 +117,6 @@ pub trait HostApi: Send + Sync {
let _ = (root, method, params, notify, cancel, timeout);
Err(HostError::NotFound(format!("no language server `{server}` is running for this project")))
}
/// The flat dependency graph of the Maven / Gradle builds of the project at `root`
/// (of the module `module` only, when given), as the IDE last resolved it; never runs
/// a build tool.
fn build_dependencies(&self, root: &Path, module: Option<&str>) -> Result<Vec<crate::DependencyNode>, HostError> {
let _ = (root, module);
Err(HostError::Failed("build data is unavailable on this host".into()))
}
/// Stdio argv only; no URL or bearer token.
fn mcp_stdio_command(&self, client: &str) -> Option<Vec<String>> {
let _ = client;
@@ -195,8 +188,8 @@ pub trait HostApi: Send + Sync {
let _ = (client, tab, cancel, timeout);
Err(HostError::Failed("content tabs unavailable".into()))
}
/// Opens a diff of two texts in the invoking window; a `None` side doesn't exist.
fn open_diff(&self, client: &str, diff: crate::FileDiff, file_name: Option<String>) -> Result<(), HostError> {
/// Opens a diff of two texts in the invoking window.
fn open_diff(&self, client: &str, diff: crate::ContentDiff, file_name: Option<String>) -> Result<(), HostError> {
let _ = (client, diff, file_name);
Err(HostError::Failed("diffs unavailable".into()))
}
-22
Переглянути файл
@@ -959,28 +959,6 @@ pub struct BlameLine {
pub summary: String,
}
/// How an occurrence in a build's dependency graph was resolved (API 1.10).
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum DependencyStatus {
Resolved,
OmittedForConflict,
OmittedForDuplicate,
VersionManaged,
}
/// One occurrence in the flat dependency graph of `build.dependencies` (API 1.10);
/// `parent` indexes the list.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct DependencyNode {
pub group: String,
pub artifact: String,
pub version: String,
pub scope: String,
pub status: DependencyStatus,
pub requested_version: Option<String>,
pub parent: Option<u32>,
}
/// Non-secret settings of a plugin-owned project database source (API 1.4).
#[derive(Clone, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
+2 -56
Переглянути файл
@@ -48,7 +48,6 @@ pub(crate) mod syntax_bindings {
"openidea:plugin/decorations": super::bindings::openidea::plugin::decorations,
"openidea:plugin/invocation": super::bindings::openidea::plugin::invocation,
"openidea:plugin/vcs": super::bindings::openidea::plugin::vcs,
"openidea:plugin/build": super::bindings::openidea::plugin::build,
"openidea:plugin/commit": super::bindings::openidea::plugin::commit,
"openidea:plugin/events": super::bindings::openidea::plugin::events,
"openidea:plugin/tasks": super::bindings::openidea::plugin::tasks,
@@ -88,7 +87,6 @@ pub(crate) mod providers_bindings {
"openidea:plugin/decorations": super::bindings::openidea::plugin::decorations,
"openidea:plugin/invocation": super::bindings::openidea::plugin::invocation,
"openidea:plugin/vcs": super::bindings::openidea::plugin::vcs,
"openidea:plugin/build": super::bindings::openidea::plugin::build,
"openidea:plugin/commit": super::bindings::openidea::plugin::commit,
"openidea:plugin/events": super::bindings::openidea::plugin::events,
"openidea:plugin/tasks": super::bindings::openidea::plugin::tasks,
@@ -128,7 +126,6 @@ pub(crate) mod views_bindings {
"openidea:plugin/decorations": super::bindings::openidea::plugin::decorations,
"openidea:plugin/invocation": super::bindings::openidea::plugin::invocation,
"openidea:plugin/vcs": super::bindings::openidea::plugin::vcs,
"openidea:plugin/build": super::bindings::openidea::plugin::build,
"openidea:plugin/commit": super::bindings::openidea::plugin::commit,
"openidea:plugin/events": super::bindings::openidea::plugin::events,
"openidea:plugin/tasks": super::bindings::openidea::plugin::tasks,
@@ -153,8 +150,8 @@ pub(crate) mod views_bindings {
}
use bindings::openidea::plugin::{
build, commit, detail_types, diagnostics, editor, events, fs, invocation, ipc, log, net, process, secrets,
settings, storage, tasks, types as wit, ui, vcs, views, workspace,
commit, detail_types, diagnostics, editor, events, fs, invocation, ipc, log, net, process, secrets, settings,
storage, tasks, types as wit, ui, vcs, views, workspace,
};
/// A project handle: its root.
@@ -1195,44 +1192,6 @@ impl vcs::Host for StoreData {
}
}
impl build::Host for StoreData {
fn dependencies(
&mut self,
project: Resource<ProjectRes>,
module: Option<String>,
) -> Fallible<Vec<build::DependencyNode>> {
if let Err(e) = self.require(Capability::BuildRead) {
return Ok(Err(e));
}
let root = self.table.get(&project)?.root.clone();
Ok(self
.host
.build_dependencies(&root, module.as_deref())
.map(|nodes| {
nodes
.into_iter()
.map(|n| build::DependencyNode {
group: n.group,
artifact: n.artifact,
version: n.version,
scope: n.scope,
status: match n.status {
crate::DependencyStatus::Resolved => build::DependencyStatus::Resolved,
crate::DependencyStatus::OmittedForConflict => build::DependencyStatus::OmittedForConflict,
crate::DependencyStatus::OmittedForDuplicate => {
build::DependencyStatus::OmittedForDuplicate
}
crate::DependencyStatus::VersionManaged => build::DependencyStatus::VersionManaged,
},
requested_version: n.requested_version,
parent: n.parent,
})
.collect()
})
.map_err(to_wit))
}
}
impl commit::Host for StoreData {
fn pending_commit(&mut self) -> Fallible<Option<commit::CommitDraft>> {
if let Err(e) = self.require(Capability::VcsRead) {
@@ -1823,13 +1782,6 @@ impl views::Host for StoreData {
.map_err(to_wit))
}
fn open_diff(&mut self, diff: views::ContentDiff, file_name: Option<String>) -> Fallible<()> {
if let Err(e) = self.require_window() {
return Ok(Err(e));
}
let diff = crate::FileDiff::from(crate::ContentDiff::from(diff));
Ok(self.host.open_diff(self.invocation.client.as_deref().unwrap(), diff, file_name).map_err(to_wit))
}
fn open_file_diff(&mut self, diff: views::FileDiff, file_name: Option<String>) -> Fallible<()> {
if let Err(e) = self.require_window() {
return Ok(Err(e));
}
@@ -2194,12 +2146,6 @@ impl From<bindings::openidea::plugin::views::ContentDiff> for crate::ContentDiff
}
}
impl From<bindings::openidea::plugin::views::FileDiff> for crate::FileDiff {
fn from(v: bindings::openidea::plugin::views::FileDiff) -> Self {
Self { left: v.left, right: v.right, left_label: v.left_label, right_label: v.right_label, title: v.title }
}
}
impl From<bindings::openidea::plugin::views::ContentTabReply> for crate::ContentTabReply {
fn from(v: bindings::openidea::plugin::views::ContentTabReply) -> Self {
Self {
+5 -5
Переглянути файл
@@ -91,15 +91,15 @@ fn the_sdk_carries_the_hosts_wit() {
#[test]
fn the_version_check_runs_compatible_components_and_explains_the_rest() {
let host = v("1.10.0");
for ok in ["1.0.0", "1.3.0", "1.4.7", "1.5.0", "1.6.0", "1.7.0", "1.8.0", "1.9.0", "1.10.0", "1.0.0-rc.1"] {
let host = v("1.9.0");
for ok in ["1.0.0", "1.3.0", "1.4.7", "1.5.0", "1.6.0", "1.7.0", "1.8.0", "1.9.0", "1.0.0-rc.1"] {
assert_eq!(check_api(&v(ok), &host), Ok(()), "{ok}");
}
let newer = check_api(&v("1.11.0"), &host).unwrap_err();
assert!(newer.contains("1.11") && newer.contains("update OpenIDEA"), "{newer}");
let newer = check_api(&v("1.10.0"), &host).unwrap_err();
assert!(newer.contains("1.10") && newer.contains("update OpenIDEA"), "{newer}");
assert!(check_api(&v("2.0.0"), &host).unwrap_err().contains("update OpenIDEA"));
let older = check_api(&v("0.2.0"), &host).unwrap_err();
assert!(older.contains("rebuild it with the 1.10 SDK"), "{older}");
assert!(older.contains("rebuild it with the 1.9 SDK"), "{older}");
// 0.x: every minor is its own API.
assert_eq!(check_api(&v("0.2.0"), &v("0.2.5")), Ok(()));
assert!(check_api(&v("0.1.0"), &v("0.2.0")).is_err());
Бінарний файл не відображається.
+1 -1
Переглянути файл
@@ -1 +1 @@
f6069ad2d31b629e4c99fbb800b3bf389ffb87ca7f24fc9cf7803fef68997ef5
75123cf60f87ec9bdd36e0b7f75efb69d000136d74c3e9da893ecd1534bdf534
Loaded 100 of 635 files, more files were not shown because too many files have changed in this diff. Show more