mirror of
https://github.com/l0ng-ai/openidea.git
synced 2026-11-21 08:03:38 +00:00
feat(debugger): attach to a running Unity Editor (#2919)
Unity projects get a debug-only "Unity Editor" run configuration, selected by default. Debug opens a picker of local Unity Editor processes with the current project first; Run > Attach to Unity Process is also available. The tool installer fetches the pinned Unity Debugger 3.0.1 adapter with SHA-256 verification, and the session reports ready once the Mono runtime is up. A missing Mono executable on macOS and Linux is reported in the picker. Refs #1436 Co-authored-by: sliencio <20137430+sliencio@users.noreply.github.com>
This commit is contained in:
@@ -120,6 +120,12 @@ fn builtin(adapter: &str) -> Option<DebuggerConfig> {
|
||||
"stdio",
|
||||
"Install GDB 14 or newer (apt install gdb, dnf install gdb, brew install gdb)",
|
||||
),
|
||||
"unity" => cfg(
|
||||
"unity-debug",
|
||||
&[],
|
||||
"stdio",
|
||||
"Install Unity Debugger in Settings > Language Servers, or configure the unity-debug tool path",
|
||||
),
|
||||
"rdbg" => cfg("rdbg", &["-O", "--port", PORT_PLACEHOLDER, "-c"], "tcp", "gem install debug"),
|
||||
// A jdtls bundle: the session is started through jdtls and reached via `debugServer`.
|
||||
"java-debug" => cfg(
|
||||
|
||||
@@ -12,6 +12,7 @@ use std::path::Path;
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Type)]
|
||||
#[serde(rename_all = "camelCase")]
|
||||
pub enum AttachKind {
|
||||
Unity,
|
||||
Java,
|
||||
Node,
|
||||
Python,
|
||||
|
||||
@@ -19,6 +19,7 @@ mod jvm_memory;
|
||||
pub mod kotlin;
|
||||
pub mod kotlin_lsp;
|
||||
mod session;
|
||||
pub mod unity;
|
||||
|
||||
use adapter::{AdapterLauncher, AdapterSpec, ProcessLauncher};
|
||||
use connection::{Connection, DapError};
|
||||
@@ -1121,6 +1122,16 @@ impl DebugManager {
|
||||
let _ = tokio::time::timeout(INIT_TIMEOUT, initialized.wait_for(|v| *v)).await;
|
||||
}
|
||||
|
||||
if s.adapter == "unity" {
|
||||
if launch_result.is_none()
|
||||
&& let Some(launch) = launch.as_mut()
|
||||
{
|
||||
launch.await?;
|
||||
launch_result = Some(());
|
||||
}
|
||||
unity::wait_for_threads(s).await?;
|
||||
}
|
||||
|
||||
// A fresh adapter has no breakpoints, so a file with none enabled needs no request; the
|
||||
// others go out together, as VS Code sends them, instead of one round trip per file.
|
||||
let (files, idle): (Vec<_>, Vec<_>) = self
|
||||
@@ -1202,6 +1213,10 @@ impl DebugManager {
|
||||
if let Some(link) = s.jdwp_link.lock().as_ref() {
|
||||
link.release();
|
||||
}
|
||||
if s.adapter == "unity" {
|
||||
unity::settle_startup(s).await;
|
||||
s.emit(ide_core::event::DebugEvent::Initialized);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
|
||||
@@ -17,7 +17,7 @@ use std::process::Stdio;
|
||||
use std::sync::Arc;
|
||||
use std::sync::Weak;
|
||||
use std::sync::atomic::{AtomicBool, AtomicI64, Ordering};
|
||||
use std::time::Duration;
|
||||
use std::time::{Duration, Instant};
|
||||
use tokio::io::{AsyncRead, AsyncReadExt};
|
||||
use tokio::process::Child;
|
||||
use tokio::sync::{mpsc, watch};
|
||||
@@ -116,6 +116,7 @@ pub(crate) struct Session {
|
||||
pub jvm_memory: tokio::sync::Mutex<crate::JvmMemoryState>,
|
||||
/// Used only by a kotlin-lsp session: see [`Session::kotlin_lsp_quirks`].
|
||||
pub(crate) quirks: kotlin_lsp::Quirks,
|
||||
pub(crate) unity_startup_activity: Mutex<Instant>,
|
||||
}
|
||||
|
||||
/// Which threads of the program are suspended: each from its `stopped` event until a
|
||||
@@ -270,6 +271,7 @@ impl Session {
|
||||
kotlin_mirror: Mutex::new(None),
|
||||
jvm_memory: tokio::sync::Mutex::default(),
|
||||
quirks: kotlin_lsp::Quirks::default(),
|
||||
unity_startup_activity: Mutex::new(Instant::now()),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -716,6 +718,15 @@ pub(crate) async fn event_loop(
|
||||
}
|
||||
|
||||
async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut body: Value) {
|
||||
if s.adapter == "unity"
|
||||
&& event == "output"
|
||||
&& body
|
||||
.get("output")
|
||||
.and_then(Value::as_str)
|
||||
.is_some_and(|text| text.starts_with("Loaded assembly:") || text.starts_with("Resolved pending breakpoint"))
|
||||
{
|
||||
*s.unity_startup_activity.lock() = Instant::now();
|
||||
}
|
||||
if let Some(mirror) = s.kotlin_mirror.lock().as_ref() {
|
||||
mirror.translate(&mut body);
|
||||
}
|
||||
@@ -724,7 +735,9 @@ async fn on_event(mgr: &Arc<DebugManager>, s: &Arc<Session>, event: &str, mut bo
|
||||
match event {
|
||||
"initialized" => {
|
||||
s.initialized.send_replace(true);
|
||||
s.emit(DebugEvent::Initialized);
|
||||
if s.adapter != "unity" {
|
||||
s.emit(DebugEvent::Initialized);
|
||||
}
|
||||
}
|
||||
"stopped" => {
|
||||
let all = body.get("allThreadsStopped").and_then(Value::as_bool).unwrap_or(false);
|
||||
|
||||
@@ -158,6 +158,7 @@ struct Script {
|
||||
/// `launch`, and a `configurationDone` sent while it runs is refused with `notStopped`.
|
||||
gdb15_starts_at_launch: bool,
|
||||
launch_after_configuration: bool,
|
||||
empty_thread_responses: usize,
|
||||
/// Requests of the adapter's own (js-debug's `setCustomBreakpoints`…) answered with an empty body.
|
||||
accept: &'static [&'static str],
|
||||
/// Requests of the adapter's own answered with a body and followed by events.
|
||||
@@ -198,6 +199,7 @@ impl Default for Script {
|
||||
close_during_startup: false,
|
||||
gdb15_starts_at_launch: false,
|
||||
launch_after_configuration: false,
|
||||
empty_thread_responses: 0,
|
||||
accept: &[],
|
||||
custom: None,
|
||||
}
|
||||
@@ -244,6 +246,8 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
let mut held: Vec<Value> = Vec::new();
|
||||
let mut stopped = false;
|
||||
let mut running = false;
|
||||
let mut thread_requests = 0;
|
||||
let mut unity = false;
|
||||
macro_rules! send {
|
||||
($v:expr) => {{
|
||||
let mut v: Value = $v;
|
||||
@@ -268,13 +272,14 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
}
|
||||
match msg["command"].as_str().unwrap_or_default() {
|
||||
"initialize" => {
|
||||
unity = msg["arguments"]["adapterID"] == "unity";
|
||||
if let Some(delay) = script.delay_initialize {
|
||||
tokio::time::sleep(delay).await;
|
||||
}
|
||||
ok!(
|
||||
msg,
|
||||
json!({
|
||||
"supportsConfigurationDoneRequest": true,
|
||||
"supportsConfigurationDoneRequest": !unity,
|
||||
"supportsCompletionsRequest": true,
|
||||
"supportsTerminateRequest": script.supports_terminate,
|
||||
"supportsSetVariable": true,
|
||||
@@ -293,8 +298,15 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
// defers it sends late).
|
||||
send!(json!({"type": "event", "event": "initialized"}));
|
||||
}
|
||||
if unity {
|
||||
send!(json!({"type": "event", "event": "initialized"}));
|
||||
}
|
||||
}
|
||||
"launch" | "attach" => {
|
||||
if unity {
|
||||
ok!(msg, Value::Null);
|
||||
continue;
|
||||
}
|
||||
if script.gdb15_starts_at_launch {
|
||||
// GDB 15 starts the program here and answers `launch` right away.
|
||||
running = true;
|
||||
@@ -448,7 +460,14 @@ async fn fake_adapter<S: AsyncRead + AsyncWrite + Unpin + Send + 'static>(stream
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
ok!(msg, json!({"threads": [{"id": 1, "name": "\"main\"@1"}]}));
|
||||
}
|
||||
"threads" => ok!(msg, json!({"threads": [{"id": 1, "name": "MainThread"}]})),
|
||||
"threads" => {
|
||||
thread_requests += 1;
|
||||
if thread_requests <= script.empty_thread_responses {
|
||||
ok!(msg, json!({"threads": []}));
|
||||
} else {
|
||||
ok!(msg, json!({"threads": [{"id": 1, "name": "MainThread"}]}));
|
||||
}
|
||||
}
|
||||
"stackTrace" => ok!(
|
||||
msg,
|
||||
json!({"stackFrames": [
|
||||
@@ -878,6 +897,32 @@ async fn stop_terminates_and_disconnects() {
|
||||
assert!(h.manager.threads(id).await.is_err());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn unity_attach_waits_for_mono_and_disconnects_without_terminating_editor() {
|
||||
let h = harness(Script { empty_thread_responses: 2, ..Script::default() });
|
||||
h.manager.set_breakpoints(PathBuf::from("/p/a.cs"), vec![bp(4)]).await.unwrap();
|
||||
let start = h.start(LaunchConfig {
|
||||
adapter: "unity".into(),
|
||||
request: "attach".into(),
|
||||
program: None,
|
||||
extra_json: Some(json!({ "name": "Unity Editor (42)", "__exceptionOptions": [] }).to_string()),
|
||||
..config()
|
||||
});
|
||||
let ready = async {
|
||||
h.wait_event(|e| matches!(e, DebugEvent::Initialized)).await;
|
||||
let commands = h.commands();
|
||||
let before_breakpoints = commands.iter().take_while(|c| *c != "setBreakpoints");
|
||||
assert!(before_breakpoints.filter(|c| *c == "threads").count() >= 3);
|
||||
assert!(commands.iter().any(|c| c == "setBreakpoints"));
|
||||
};
|
||||
let (id, ()) = tokio::join!(start, ready);
|
||||
let id = id.unwrap();
|
||||
assert_eq!(h.request("attach")["arguments"]["name"], "Unity Editor (42)");
|
||||
h.manager.stop(id).await.unwrap();
|
||||
assert!(!h.commands().iter().any(|c| c == "launch" || c == "terminate"));
|
||||
assert_eq!(h.request("disconnect")["arguments"]["terminateDebuggee"], false);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn concurrent_sessions_are_independent() {
|
||||
let h = harness(Script::default());
|
||||
|
||||
@@ -0,0 +1,187 @@
|
||||
//! Lists the Unity Editors to attach to through UnityDebug's discovery (`unity-debug list`).
|
||||
|
||||
use crate::{
|
||||
adapter,
|
||||
attach::{AttachKind, AttachableProcess},
|
||||
};
|
||||
use ide_core::{IdeError, IdeResult};
|
||||
use std::{path::PathBuf, process::Stdio, time::Duration};
|
||||
|
||||
/// Waits until Mono reports its threads.
|
||||
pub(crate) async fn wait_for_threads(session: &crate::session::Session) -> IdeResult<()> {
|
||||
tokio::time::timeout(Duration::from_secs(20), async {
|
||||
loop {
|
||||
let body = session.conn.request_timeout("threads", serde_json::json!({}), Duration::from_secs(5)).await?;
|
||||
if body.get("threads").and_then(serde_json::Value::as_array).is_some_and(|t| !t.is_empty()) {
|
||||
return Ok(());
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
}
|
||||
})
|
||||
.await
|
||||
.map_err(|_| {
|
||||
IdeError::unavailable(
|
||||
"Unity debugger did not become ready. Enable Editor Attaching and Debug Mode in Unity, then retry.",
|
||||
)
|
||||
})?
|
||||
}
|
||||
|
||||
// Mono binds breakpoints asynchronously and resumes threads itself during startup: wait for that burst to end.
|
||||
pub(crate) async fn settle_startup(session: &crate::session::Session) {
|
||||
*session.unity_startup_activity.lock() = std::time::Instant::now();
|
||||
let _ = tokio::time::timeout(Duration::from_secs(3), async {
|
||||
while session.unity_startup_activity.lock().elapsed() < Duration::from_secs(1) {
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
}
|
||||
})
|
||||
.await;
|
||||
}
|
||||
|
||||
pub fn require_runtime(cwd: &std::path::Path) -> IdeResult<()> {
|
||||
if cfg!(unix) && ide_core::tool_path::find_command("mono", &ide_core::tool_path::search_path(), cwd).is_none() {
|
||||
return Err(IdeError::unavailable(
|
||||
"Unity Debugger requires Mono. Install Mono, make sure mono is on PATH, then refresh the Unity process list.",
|
||||
));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
const NOT_INSTALLED: &str = "debug adapter `unity` not found. Install Unity Debugger in Settings > Language Servers or configure the unity-debug tool path";
|
||||
|
||||
pub async fn editors(command: Option<String>, cwd: PathBuf) -> IdeResult<Vec<AttachableProcess>> {
|
||||
require_runtime(&cwd)?;
|
||||
let command = command.unwrap_or_else(|| "unity-debug".into());
|
||||
let lookup = command.clone();
|
||||
let dir = cwd.clone();
|
||||
let binary = tokio::task::spawn_blocking(move || adapter::resolve_binary(&lookup, &dir))
|
||||
.await
|
||||
.map_err(|e| IdeError::internal(e.to_string()))?
|
||||
.ok_or_else(|| IdeError::unavailable(NOT_INSTALLED))?;
|
||||
let mut cmd = tokio::process::Command::new(binary);
|
||||
ide_core::process::prepare(cmd.as_std_mut());
|
||||
cmd.arg("list")
|
||||
.current_dir(&cwd)
|
||||
.env("PATH", ide_core::tool_path::search_path())
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::piped())
|
||||
.stderr(Stdio::piped())
|
||||
.kill_on_drop(true);
|
||||
let out = tokio::time::timeout(Duration::from_secs(15), cmd.output())
|
||||
.await
|
||||
.map_err(|_| {
|
||||
IdeError::unavailable("Unity process discovery timed out. Check that Unity Editor is responsive.")
|
||||
})?
|
||||
.map_err(|e| IdeError::unavailable(format!("Cannot start Unity process discovery: {e}")))?;
|
||||
if !out.status.success() {
|
||||
return Err(IdeError::unavailable(format!(
|
||||
"Unity process discovery failed: {}",
|
||||
String::from_utf8_lossy(&out.stderr).trim()
|
||||
)));
|
||||
}
|
||||
let mut rows = parse_editors(&String::from_utf8_lossy(&out.stdout));
|
||||
#[cfg(windows)]
|
||||
if !rows.is_empty() {
|
||||
match editor_process_ids() {
|
||||
Ok(editors) => rows.retain(|p| editors.contains(&p.pid)),
|
||||
Err(error) => tracing::warn!(%error, "Unity process filtering failed; using adapter discovery results"),
|
||||
}
|
||||
}
|
||||
// The Editor of the open project comes first; the user picks which one to attach to.
|
||||
let path = cwd.join("Library/EditorInstance.json");
|
||||
let pid = std::fs::File::open(path).ok().and_then(|file| {
|
||||
use std::io::Read;
|
||||
let json: serde_json::Value = serde_json::from_reader(file.take(4096)).ok()?;
|
||||
json.get("process_id")?.as_u64().and_then(|n| u32::try_from(n).ok())
|
||||
});
|
||||
for row in &mut rows {
|
||||
if Some(row.pid) == pid {
|
||||
row.command_line = cwd.to_string_lossy().into_owned();
|
||||
}
|
||||
}
|
||||
rows.sort_by_key(|p| Some(p.pid) != pid);
|
||||
Ok(rows)
|
||||
}
|
||||
|
||||
#[cfg(windows)]
|
||||
fn editor_process_ids() -> IdeResult<std::collections::HashSet<u32>> {
|
||||
use std::collections::HashMap;
|
||||
use windows_sys::Win32::{
|
||||
Foundation::{CloseHandle, INVALID_HANDLE_VALUE},
|
||||
System::Diagnostics::ToolHelp::{
|
||||
CreateToolhelp32Snapshot, PROCESSENTRY32W, Process32FirstW, Process32NextW, TH32CS_SNAPPROCESS,
|
||||
},
|
||||
};
|
||||
|
||||
let mut unity = HashMap::new();
|
||||
// The adapter also finds the asset import worker processes: keep the Unity processes whose parent isn't Unity.
|
||||
unsafe {
|
||||
let snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
|
||||
if snapshot == INVALID_HANDLE_VALUE {
|
||||
return Err(std::io::Error::last_os_error().into());
|
||||
}
|
||||
let mut entry = PROCESSENTRY32W { dwSize: std::mem::size_of::<PROCESSENTRY32W>() as u32, ..std::mem::zeroed() };
|
||||
let mut found = Process32FirstW(snapshot, &mut entry);
|
||||
if found == 0 {
|
||||
let error = std::io::Error::last_os_error();
|
||||
CloseHandle(snapshot);
|
||||
return Err(error.into());
|
||||
}
|
||||
while found != 0 {
|
||||
let end = entry.szExeFile.iter().position(|c| *c == 0).unwrap_or(entry.szExeFile.len());
|
||||
let name = String::from_utf16_lossy(&entry.szExeFile[..end]);
|
||||
if name.eq_ignore_ascii_case("Unity.exe") {
|
||||
unity.insert(entry.th32ProcessID, entry.th32ParentProcessID);
|
||||
}
|
||||
found = Process32NextW(snapshot, &mut entry);
|
||||
}
|
||||
CloseHandle(snapshot);
|
||||
}
|
||||
Ok(unity.iter().filter_map(|(&pid, parent)| (!unity.contains_key(parent)).then_some(pid)).collect())
|
||||
}
|
||||
|
||||
pub fn parse_editors(output: &str) -> Vec<AttachableProcess> {
|
||||
let mut editors = Vec::new();
|
||||
for line in output.lines() {
|
||||
let line = line.trim().trim_start_matches('\u{feff}');
|
||||
if !line.starts_with("Unity Editor (") {
|
||||
continue;
|
||||
}
|
||||
// 3.0.1 prints `Unity Editor (Unity) (123)`; later versions append the project name.
|
||||
let Some((name, pid, project)) = line.match_indices(" (").find_map(|(at, _)| {
|
||||
let (id, project) = line[at + 2..].split_once(')')?;
|
||||
let pid = id.parse::<u32>().ok().filter(|n| *n > 0)?;
|
||||
Some((&line[..at], pid, project))
|
||||
}) else {
|
||||
continue;
|
||||
};
|
||||
if editors.iter().any(|p: &AttachableProcess| p.pid == pid) {
|
||||
continue;
|
||||
}
|
||||
editors.push(AttachableProcess {
|
||||
pid,
|
||||
name: "Unity Editor".into(),
|
||||
command_line: if project.trim().is_empty() { name.into() } else { project.trim().into() },
|
||||
kind: AttachKind::Unity,
|
||||
adapter: "unity".into(),
|
||||
host: None,
|
||||
port: None,
|
||||
});
|
||||
}
|
||||
editors.sort_by(|a, b| a.command_line.cmp(&b.command_line).then(a.pid.cmp(&b.pid)));
|
||||
editors
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
#[test]
|
||||
fn parses_editor_ids_and_projects_without_mistaking_players_or_logs_for_editors() {
|
||||
let rows = parse_editors(
|
||||
"\u{feff}Unity Editor (Unity) (42) Game (Test)\r\nUnity Editor (7) My Game\nUnity Editor (42) duplicate\nWindowsPlayer (123) Player\nUnity Hub (44)\nUnity Editor (invalid)\nUnity Editor (0)\nlog text",
|
||||
);
|
||||
assert_eq!(rows.len(), 2);
|
||||
assert_eq!((rows[0].pid, rows[0].command_line.as_str()), (42, "Game (Test)"));
|
||||
assert_eq!(rows[1].pid, 7);
|
||||
assert!(rows.iter().all(|p| p.kind == AttachKind::Unity && p.adapter == "unity"));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,187 @@
|
||||
//! Attaches to a real Unity Editor, with its own temporary project and Editor instance.
|
||||
//! OPENIDEA_UNITY_EDITOR=<Unity.exe> OPENIDEA_UNITY_ADAPTER=<UnityDebug.exe>
|
||||
//! cargo test -p ide-dap --test unity -- --ignored --nocapture
|
||||
|
||||
use ide_core::{IdeEvent, SharedSink, event::DebugEvent};
|
||||
use ide_dap::{Breakpoint, DebugManager, LaunchConfig, SessionOwner, StepKind};
|
||||
use ide_language::LanguageRegistry;
|
||||
use parking_lot::Mutex;
|
||||
use std::{collections::BTreeMap, path::PathBuf, sync::Arc, time::Duration};
|
||||
|
||||
const SCRIPT: &str = r#"using System.IO;
|
||||
using UnityEditor;
|
||||
using UnityEngine;
|
||||
[InitializeOnLoad]
|
||||
public static class OpenIdeaAttachProbe
|
||||
{
|
||||
static readonly string Root = Directory.GetParent(Application.dataPath).FullName;
|
||||
static OpenIdeaAttachProbe()
|
||||
{
|
||||
EditorApplication.update += Tick;
|
||||
}
|
||||
static void Tick()
|
||||
{
|
||||
if (EditorApplication.isCompiling || EditorApplication.isUpdating) return;
|
||||
if (!File.Exists(Path.Combine(Root, "ready")))
|
||||
File.WriteAllText(Path.Combine(Root, "ready"), System.Diagnostics.Process.GetCurrentProcess().Id.ToString());
|
||||
if (File.Exists(Path.Combine(Root, "exit"))) { EditorApplication.Exit(0); return; }
|
||||
if (!File.Exists(Path.Combine(Root, "go"))) return;
|
||||
File.Delete(Path.Combine(Root, "go"));
|
||||
int result = Hit(41);
|
||||
File.WriteAllText(Path.Combine(Root, "done"), result.ToString());
|
||||
}
|
||||
static int Hit(int seed)
|
||||
{
|
||||
int answer = seed + 1;
|
||||
return answer;
|
||||
}
|
||||
}
|
||||
"#;
|
||||
|
||||
async fn stopped(events: &Mutex<Vec<IdeEvent>>, expected_reason: &str) -> i64 {
|
||||
for _ in 0..600 {
|
||||
if let Some(thread) = events.lock().iter().find_map(|e| match e {
|
||||
IdeEvent::Debug { event: DebugEvent::Stopped { thread_id, reason, .. }, .. }
|
||||
if reason == expected_reason =>
|
||||
{
|
||||
Some(*thread_id)
|
||||
}
|
||||
_ => None,
|
||||
}) {
|
||||
return thread;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(50)).await;
|
||||
}
|
||||
let events = events.lock();
|
||||
panic!("No breakpoint/step event: {:?}", &events[events.len().saturating_sub(16)..]);
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
|
||||
#[ignore = "needs a licensed Unity Editor and the Unity DAP adapter"]
|
||||
async fn real_editor_attach_breakpoint_step_variables_and_detach() {
|
||||
let editor = std::env::var("OPENIDEA_UNITY_EDITOR").expect("OPENIDEA_UNITY_EDITOR");
|
||||
let adapter = std::env::var("OPENIDEA_UNITY_ADAPTER").expect("OPENIDEA_UNITY_ADAPTER");
|
||||
let target = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../target").canonicalize().unwrap();
|
||||
// Keep the Editor log for diagnosing a failure.
|
||||
let root = tempfile::Builder::new().prefix("unity-dap-smoke-").tempdir_in(target).unwrap().keep();
|
||||
let root = root.to_string_lossy().trim_start_matches(r"\\?\").replace('\\', "/");
|
||||
let root = PathBuf::from(root);
|
||||
std::fs::create_dir_all(root.join("Assets/Editor")).unwrap();
|
||||
std::fs::create_dir(root.join("ProjectSettings")).unwrap();
|
||||
std::fs::create_dir(root.join("Packages")).unwrap();
|
||||
std::fs::write(
|
||||
root.join("ProjectSettings/ProjectVersion.txt"),
|
||||
format!(
|
||||
"m_EditorVersion: {}\n",
|
||||
PathBuf::from(&editor).ancestors().nth(2).and_then(|p| p.file_name()).unwrap().to_string_lossy()
|
||||
),
|
||||
)
|
||||
.unwrap();
|
||||
std::fs::write(root.join("Packages/manifest.json"), r#"{"dependencies":{}}"#).unwrap();
|
||||
let source = root.join("Assets/Editor/OpenIdeaAttachProbe.cs");
|
||||
std::fs::write(&source, SCRIPT).unwrap();
|
||||
let mut command = tokio::process::Command::new(&editor);
|
||||
ide_core::process::prepare(command.as_std_mut());
|
||||
// The test project has no packages: skip the package manager.
|
||||
command
|
||||
.args(["-batchmode", "-nographics", "-noUpm", "-debugCodeOptimization", "-projectPath"])
|
||||
.arg(&root)
|
||||
.arg("-logFile")
|
||||
.arg(root.join("Editor.log"))
|
||||
.current_dir(&root)
|
||||
.kill_on_drop(true);
|
||||
let mut child = command.spawn().unwrap();
|
||||
let pid = child.id().unwrap();
|
||||
eprintln!("Isolated Unity pid {pid}, project {}", root.display());
|
||||
for _ in 0..1200 {
|
||||
if root.join("ready").exists() {
|
||||
break;
|
||||
}
|
||||
assert!(child.try_wait().unwrap().is_none(), "Unity exited; inspect {}/Editor.log", root.display());
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
}
|
||||
assert!(root.join("ready").exists(), "Editor failed to load the test script");
|
||||
let rows = ide_dap::unity::editors(Some(adapter.clone()), root.clone()).await.unwrap();
|
||||
assert!(rows.iter().any(|p| p.pid == pid), "test Editor absent: {rows:?}");
|
||||
let events: Arc<Mutex<Vec<IdeEvent>>> = Arc::default();
|
||||
let saved = events.clone();
|
||||
let sink: SharedSink = Arc::new(move |event| saved.lock().push(event));
|
||||
let manager = DebugManager::new(Arc::new(LanguageRegistry::from_configs(Vec::new())));
|
||||
let line = SCRIPT.lines().position(|l| l.contains("int answer =")).unwrap() as u32;
|
||||
manager
|
||||
.set_breakpoints(
|
||||
source.clone(),
|
||||
vec![Breakpoint { line, condition: None, hit_condition: None, log_message: None, enabled: true }],
|
||||
)
|
||||
.await
|
||||
.unwrap();
|
||||
let start = || {
|
||||
manager.start_with(
|
||||
LaunchConfig {
|
||||
name: format!("Unity Editor ({pid})"),
|
||||
adapter: "unity".into(),
|
||||
request: "attach".into(),
|
||||
program: None,
|
||||
args: vec![],
|
||||
cwd: Some(root.clone().into()),
|
||||
env: BTreeMap::new(),
|
||||
extra_json: Some(
|
||||
serde_json::json!({ "name": format!("Unity Editor ({pid})"), "__exceptionOptions": [] })
|
||||
.to_string(),
|
||||
),
|
||||
},
|
||||
SessionOwner::new("smoke", sink.clone()),
|
||||
|_| Some(adapter.clone()),
|
||||
)
|
||||
};
|
||||
let session = start().await.unwrap();
|
||||
eprintln!("Attached; breakpoint states: {:?}", manager.breakpoint_states(&source));
|
||||
// Mono is ready to run once the start returns.
|
||||
assert!(!manager.threads(session).await.unwrap().is_empty());
|
||||
std::fs::write(root.join("go"), "").unwrap();
|
||||
let thread = stopped(&events, "breakpoint").await;
|
||||
let frames = manager.stack_trace(session, thread).await.unwrap();
|
||||
assert!(!frames.is_empty(), "Empty breakpoint stack: {:?}", events.lock());
|
||||
assert_eq!(frames[0].line, line);
|
||||
let scopes = manager.scopes(session, frames[0].id).await.unwrap();
|
||||
let variables = manager.variables(session, scopes[0].variables_reference).await.unwrap();
|
||||
assert!(variables.iter().any(|v| v.name == "seed" && v.value == "41"), "{variables:?}");
|
||||
assert_eq!(manager.evaluate(session, Some(frames[0].id), "seed + 1".into()).await.unwrap().value, "42");
|
||||
events.lock().clear();
|
||||
manager.step(session, thread, StepKind::Over).await.unwrap();
|
||||
let thread = stopped(&events, "step").await;
|
||||
let frames = manager.stack_trace(session, thread).await.unwrap();
|
||||
assert!(!frames.is_empty(), "Empty step stack: {:?}", events.lock());
|
||||
assert!(frames[0].line > line);
|
||||
// Detaching at a breakpoint resumes the Editor.
|
||||
manager.stop(session).await.unwrap();
|
||||
verify_resumed(&root, &mut child).await;
|
||||
|
||||
// Attaching again to the same Editor hits the existing breakpoint.
|
||||
std::fs::remove_file(root.join("done")).unwrap();
|
||||
events.lock().clear();
|
||||
let session = start().await.unwrap_or_else(|error| {
|
||||
let events = events.lock();
|
||||
panic!("Reattach failed: {error:?}, recent events: {:?}", &events[events.len().saturating_sub(12)..]);
|
||||
});
|
||||
std::fs::write(root.join("go"), "").unwrap();
|
||||
let thread = stopped(&events, "breakpoint").await;
|
||||
assert_eq!(manager.stack_trace(session, thread).await.unwrap()[0].line, line);
|
||||
manager.stop(session).await.unwrap();
|
||||
verify_resumed(&root, &mut child).await;
|
||||
std::fs::write(root.join("exit"), "").unwrap();
|
||||
assert!(tokio::time::timeout(Duration::from_secs(30), child.wait()).await.unwrap().unwrap().success());
|
||||
eprintln!("Verified discovery, attachment, breakpoint, locals, evaluation, step, detach and reattachment");
|
||||
}
|
||||
|
||||
async fn verify_resumed(root: &std::path::Path, child: &mut tokio::process::Child) {
|
||||
let path = root.join("done");
|
||||
for _ in 0..100 {
|
||||
assert!(child.try_wait().unwrap().is_none(), "disconnect terminated the Unity Editor");
|
||||
if std::fs::read_to_string(&path).is_ok_and(|text| text == "42") {
|
||||
return;
|
||||
}
|
||||
tokio::time::sleep(Duration::from_millis(100)).await;
|
||||
}
|
||||
panic!("Unity did not complete the script after disconnect: {:?}", std::fs::read_to_string(path));
|
||||
}
|
||||
@@ -12,6 +12,25 @@ use std::path::PathBuf;
|
||||
/// Starts a session owned by this window: its events (and those of child sessions) go here only.
|
||||
pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> IdeResult<DebugSessionId> {
|
||||
host.require_trust(window)?;
|
||||
let unity_pid = if config.adapter == "unity" {
|
||||
if config.request != "attach" {
|
||||
return Err(ide_core::IdeError::invalid("Unity debugging only supports attachment to a running Editor"));
|
||||
}
|
||||
let arguments = launch_arguments(&config)?;
|
||||
let pid = arguments["name"]
|
||||
.as_str()
|
||||
.and_then(|name| name.strip_prefix("Unity Editor ("))
|
||||
.and_then(|name| name.strip_suffix(')'))
|
||||
.and_then(|pid| pid.parse::<u32>().ok());
|
||||
if let Some(pid) = pid {
|
||||
require_unity_editor(pid)?;
|
||||
}
|
||||
let cwd = config.cwd.as_ref().map(|path| path.as_ref()).unwrap_or_else(|| std::path::Path::new("."));
|
||||
unity::require_runtime(cwd)?;
|
||||
pid
|
||||
} else {
|
||||
None
|
||||
};
|
||||
let mut config = match_java_debug_encoding(start_java_attach_listener(config, cfg!(windows)), cfg!(windows));
|
||||
if config.adapter == "debugpy"
|
||||
&& config.request == "launch"
|
||||
@@ -100,12 +119,26 @@ pub async fn debug_start(host: &Host, window: &str, config: LaunchConfig) -> Ide
|
||||
let server_port = debug_server_port(&config);
|
||||
let result = host.debugger.start_with(config, owner, custom).await;
|
||||
flush_output();
|
||||
if result.is_err()
|
||||
&& let Some(pid) = unity_pid
|
||||
{
|
||||
require_unity_editor(pid)?;
|
||||
}
|
||||
if let (Ok(id), Some(port)) = (&result, server_port) {
|
||||
attach_jvm_inspector(host, window, *id, port);
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
fn require_unity_editor(pid: u32) -> IdeResult<()> {
|
||||
if !ide_core::process::process_alive(pid) {
|
||||
return Err(ide_core::IdeError::unavailable(format!(
|
||||
"Unity Editor (PID {pid}) is no longer running. Refresh the Unity process list and select a running Editor."
|
||||
)));
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The port of the java-debug server this machine's jdtls started; `debugServer` as `host:port`
|
||||
/// names an adapter on another machine, whose jdtls is not ours to ask.
|
||||
fn debug_server_port(config: &LaunchConfig) -> Option<u16> {
|
||||
@@ -460,6 +493,17 @@ pub async fn debug_free_port(host: &Host, window: &str) -> IdeResult<u16> {
|
||||
ide_dap::adapter::free_port().map_err(ide_core::IdeError::from)
|
||||
}
|
||||
|
||||
pub async fn debug_unity_processes(host: &Host, window: &str) -> IdeResult<Vec<attach::AttachableProcess>> {
|
||||
host.require_trust(window)?;
|
||||
let project = host.project(window)?;
|
||||
if ide_workspace::unity::detect(&project.root).is_none() {
|
||||
return Err(ide_core::IdeError::invalid("Open a Unity project before attaching to the Editor"));
|
||||
}
|
||||
let command = ide_sdk::apply::tool_command(&project.root, &project.settings.effective(), "unity-debug")
|
||||
.map(|p| p.to_string_lossy().into_owned());
|
||||
unity::editors(command, project.root.clone()).await
|
||||
}
|
||||
|
||||
/// Remote JVM Debug in listen mode: waits (cancellable through `request`) for the remote
|
||||
/// JVM to connect to `host:port`; returns the loopback port java-debug attaches to.
|
||||
pub async fn debug_listen_for_jvm(
|
||||
@@ -664,6 +708,7 @@ pub(crate) fn register(d: &mut Dispatcher) {
|
||||
});
|
||||
d.add("debug_attachable_processes", |c| async move { debug_attachable_processes(&c.host, &c.window).await });
|
||||
d.add("debug_free_port", |c| async move { debug_free_port(&c.host, &c.window).await });
|
||||
d.add("debug_unity_processes", |c| async move { debug_unity_processes(&c.host, &c.window).await });
|
||||
d.add("debug_listen_for_jvm", |c| async move {
|
||||
debug_listen_for_jvm(&c.host, &c.window, c.arg("request")?, c.arg("host")?, c.arg("port")?).await
|
||||
});
|
||||
|
||||
@@ -338,6 +338,15 @@ pub fn env_wrapper(bin_dir: &Path, command: &str, target: &Path, env: &[(&str, &
|
||||
}
|
||||
|
||||
pub fn link_executable(bin_dir: &Path, command: &str, target: &Path) -> IdeResult<PathBuf> {
|
||||
link_executable_with_runtime(bin_dir, command, target, None)
|
||||
}
|
||||
|
||||
pub fn link_executable_with_runtime(
|
||||
bin_dir: &Path,
|
||||
command: &str,
|
||||
target: &Path,
|
||||
runtime: Option<&str>,
|
||||
) -> IdeResult<PathBuf> {
|
||||
fs::create_dir_all(bin_dir)?;
|
||||
#[cfg(unix)]
|
||||
{
|
||||
@@ -347,7 +356,8 @@ pub fn link_executable(bin_dir: &Path, command: &str, target: &Path) -> IdeResul
|
||||
}
|
||||
let quoted = target.to_string_lossy().replace('\'', r"'\''");
|
||||
// A Node script without a shebang (e.g. js-debug's dapDebugServer.js) runs through `node`.
|
||||
let runner = if target.extension().is_some_and(|e| e == "js") { "node " } else { "" };
|
||||
let runner = runtime.or_else(|| target.extension().is_some_and(|e| e == "js").then_some("node"));
|
||||
let runner = runner.map(|r| format!("{r} ")).unwrap_or_default();
|
||||
fs::write(&link, format!("#!/bin/sh\nexec {runner}'{quoted}' \"$@\"\n"))?;
|
||||
make_executable(&link)?;
|
||||
make_executable(target)?;
|
||||
@@ -356,7 +366,8 @@ pub fn link_executable(bin_dir: &Path, command: &str, target: &Path) -> IdeResul
|
||||
#[cfg(not(unix))]
|
||||
{
|
||||
let link = bin_dir.join(format!("{command}.cmd"));
|
||||
let runner = if target.extension().is_some_and(|e| e == "js") { "node " } else { "" };
|
||||
let runner = runtime.or_else(|| target.extension().is_some_and(|e| e == "js").then_some("node"));
|
||||
let runner = runner.map(|r| format!("{r} ")).unwrap_or_default();
|
||||
fs::write(&link, format!("@echo off\r\n{runner}\"{}\" %*\r\n", cmd_path(bin_dir, target)))?;
|
||||
Ok(link)
|
||||
}
|
||||
@@ -510,6 +521,34 @@ mod tests {
|
||||
assert!(dest.join("ok.txt").exists());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unity_vsix_wrapper_preserves_managed_assemblies_and_uses_mono_on_unix() {
|
||||
let tmp = tempfile::tempdir().unwrap();
|
||||
let archive = tmp.path().join("unity.vsix");
|
||||
zip_file(
|
||||
&archive,
|
||||
&[
|
||||
("extension/bin/UnityDebug.exe", b"adapter", 0o644),
|
||||
("extension/bin/UnityDebug.exe.config", b"runtime config", 0o644),
|
||||
("extension/bin/Mono.Debugger.Soft.dll", b"dependency", 0o644),
|
||||
],
|
||||
);
|
||||
let dest = tmp.path().join("install with spaces");
|
||||
extract(&archive, ArchiveKind::Zip, &dest, "unity-debug", &CancellationToken::new()).unwrap();
|
||||
let target = locate(&dest, &["UnityDebug.exe".into()]).unwrap();
|
||||
let wrapper =
|
||||
link_executable_with_runtime(&dest.join("bin"), "unity-debug", &target, cfg!(unix).then_some("mono"))
|
||||
.unwrap();
|
||||
let script = fs::read_to_string(wrapper).unwrap();
|
||||
assert!(script.contains(&*target.to_string_lossy()));
|
||||
#[cfg(unix)]
|
||||
assert!(script.contains("exec mono '") && script.contains("\"$@\""));
|
||||
#[cfg(windows)]
|
||||
assert!(script.contains("\" %*") && !script.contains("mono "));
|
||||
assert_eq!(fs::read(target.with_extension("exe.config")).unwrap(), b"runtime config");
|
||||
assert_eq!(fs::read(target.parent().unwrap().join("Mono.Debugger.Soft.dll")).unwrap(), b"dependency");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn zip_symlinks_are_confined_to_the_destination() {
|
||||
for target in ["../outside", "/tmp/outside", "a/../../outside"] {
|
||||
|
||||
@@ -1296,6 +1296,14 @@ impl Tools {
|
||||
cancel: &CancellationToken,
|
||||
) -> IdeResult<sources::Download> {
|
||||
match source {
|
||||
ReleaseSource::Fixed { version, url, sha256 } => Ok(sources::Download {
|
||||
version: version.into(),
|
||||
name: url.rsplit('/').next().unwrap_or("download").into(),
|
||||
url: url.into(),
|
||||
size: None,
|
||||
sha256: Some(sha256.into()),
|
||||
checksum_url: None,
|
||||
}),
|
||||
ReleaseSource::GitHub { repo } => match http.get_text(&sources::github_latest_url(repo), cancel) {
|
||||
Ok(json) => sources::github_pick(&json, assets, self.platform),
|
||||
Err(e) if e.kind == ErrorKind::Cancelled => Err(e),
|
||||
@@ -1442,7 +1450,11 @@ impl Tools {
|
||||
} else {
|
||||
archive::make_executable(&target)?;
|
||||
if self.exe_in(&bin, main).as_deref() != Some(target.as_path()) {
|
||||
archive::link_executable(&bin, main, &target)?;
|
||||
if spec.name == "unity-debug" && cfg!(unix) {
|
||||
archive::link_executable_with_runtime(&bin, main, &target, Some("mono"))?;
|
||||
} else {
|
||||
archive::link_executable(&bin, main, &target)?;
|
||||
}
|
||||
}
|
||||
}
|
||||
self.write_manifest(spec.name, &Manifest { version: Some(dl.version.clone()), source: Some(dl.url.clone()) })
|
||||
|
||||
@@ -20,6 +20,8 @@ pub enum ToolKind {
|
||||
/// Where release archives come from.
|
||||
#[derive(Clone, Copy, Debug)]
|
||||
pub enum ReleaseSource {
|
||||
/// One pinned archive, verified against its SHA-256 before extraction.
|
||||
Fixed { version: &'static str, url: &'static str, sha256: &'static str },
|
||||
/// Latest GitHub release of `owner/repo`; assets plus links in the release notes.
|
||||
GitHub { repo: &'static str },
|
||||
/// `api.releases.hashicorp.com` product.
|
||||
@@ -80,6 +82,7 @@ impl Method {
|
||||
Method::Release { source: ReleaseSource::EclipseJdtls, .. } => "Eclipse download",
|
||||
Method::Release { source: ReleaseSource::OpenVsx { .. }, .. } => "Open VSX",
|
||||
Method::Release { source: ReleaseSource::MavenCentral { .. }, .. } => "Maven Central",
|
||||
Method::Release { source: ReleaseSource::Fixed { .. }, .. } => "Verified download",
|
||||
Method::Release { .. } => "GitHub release",
|
||||
}
|
||||
}
|
||||
@@ -131,6 +134,29 @@ const fn ver(cmd: &'static str) -> Option<(&'static str, &'static [&'static str]
|
||||
pub const TYPESCRIPT: &str = "typescript@6";
|
||||
|
||||
pub static TOOLS: &[ToolSpec] = &[
|
||||
ToolSpec {
|
||||
name: "unity-debug",
|
||||
display: "Unity Debugger",
|
||||
kind: Debugger,
|
||||
commands: &["unity-debug"],
|
||||
method: Method::Release {
|
||||
source: ReleaseSource::Fixed {
|
||||
version: "3.0.1",
|
||||
url: "https://github.com/Unity-Technologies/vscode-unity-debug/releases/download/Version-3.0.1/unity-debug-3.0.1.vsix",
|
||||
sha256: "4fa00660e0b52b0413726f80962e7d3d6efd41ac6cfd4df39520cae4a8ba5bd0",
|
||||
},
|
||||
assets: &[any_arch(Mac, "*.vsix"), any_arch(Linux, "*.vsix"), any_arch(Windows, "*.vsix")],
|
||||
locate: &["UnityDebug.exe"],
|
||||
},
|
||||
fallback: None,
|
||||
version: V,
|
||||
homepage: "https://github.com/Unity-Technologies/vscode-unity-debug",
|
||||
needs: if cfg!(windows) {
|
||||
&[]
|
||||
} else {
|
||||
&[("mono", "Mono is required to run the Unity debugger (https://www.mono-project.com)")]
|
||||
},
|
||||
},
|
||||
ToolSpec {
|
||||
name: "prettier",
|
||||
display: "Prettier",
|
||||
@@ -1164,6 +1190,8 @@ mod tests {
|
||||
fn registry_names_match_language_configs() {
|
||||
let langs = ide_language::LanguageRegistry::load(None).unwrap().all();
|
||||
let mut known = std::collections::HashSet::new();
|
||||
// The Unity debugger comes with Unity projects, apart from the C# debugger.
|
||||
known.insert(("unity-debug".to_owned(), "unity-debug".to_owned()));
|
||||
for l in &langs {
|
||||
for s in &l.language_servers {
|
||||
known.insert((s.name.clone(), s.command.clone()));
|
||||
|
||||
@@ -49,6 +49,24 @@ fn find<'a>(list: &'a [ToolInfo], name: &str) -> &'a ToolInfo {
|
||||
list.iter().find(|t| t.name == name).unwrap_or_else(|| panic!("{name} not listed"))
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn unity_adapter_download_is_pinned_and_checksum_verified() {
|
||||
let env = Env::new();
|
||||
let tools = env.tools();
|
||||
let spec = registry::find("unity-debug").unwrap();
|
||||
let Method::Release { source, assets, locate } = spec.method else { panic!("expected release") };
|
||||
// A fixed release resolves without a network request.
|
||||
let curl = env.sys.join(if cfg!(windows) { "curl.exe" } else { "curl" });
|
||||
fs::write(&curl, b"unused").unwrap();
|
||||
archive::make_executable(&curl).unwrap();
|
||||
let http = Http::new(env.sys.as_os_str()).unwrap();
|
||||
let download = tools.resolve_release(&http, source, assets, &CancellationToken::new()).unwrap();
|
||||
assert_eq!(download.version, "3.0.1");
|
||||
assert!(download.url.starts_with("https://github.com/Unity-Technologies/vscode-unity-debug/releases/download/"));
|
||||
assert_eq!(download.sha256.as_deref(), Some("4fa00660e0b52b0413726f80962e7d3d6efd41ac6cfd4df39520cae4a8ba5bd0"));
|
||||
assert_eq!(locate, &["UnityDebug.exe"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bundled_lombok_replaces_legacy_installs_on_every_platform_without_downloads() {
|
||||
for os in [Os::Mac, Os::Linux, Os::Windows] {
|
||||
|
||||
@@ -348,6 +348,15 @@ pub async fn debug_free_port(window: Window, state: State<'_, AppState>) -> IdeR
|
||||
ide_host::ops::debug::debug_free_port(&state.host, window.label()).await
|
||||
}
|
||||
|
||||
#[tauri::command]
|
||||
#[specta::specta]
|
||||
pub async fn debug_unity_processes(
|
||||
window: tauri::Window,
|
||||
state: State<'_, AppState>,
|
||||
) -> IdeResult<Vec<attach::AttachableProcess>> {
|
||||
ide_host::ops::debug::debug_unity_processes(&state.host, window.label()).await
|
||||
}
|
||||
|
||||
/// Remote JVM Debug in listen mode: waits (cancellable through `request`) for the remote
|
||||
/// JVM to connect to `host:port`; returns the loopback port java-debug attaches to.
|
||||
#[tauri::command]
|
||||
|
||||
@@ -553,6 +553,7 @@ pub fn builder() -> tauri_specta::Builder<tauri::Wry> {
|
||||
debug::debug_data_breakpoint_info,
|
||||
debug::debug_attachable_processes,
|
||||
debug::debug_free_port,
|
||||
debug::debug_unity_processes,
|
||||
debug::debug_listen_for_jvm,
|
||||
debug::debug_redefine_classes,
|
||||
debug::debug_jvm_memory_classes,
|
||||
|
||||
@@ -165,6 +165,7 @@ debug_step_in_target trusted project_host bin
|
||||
debug_step_in_targets trusted project_host bindings async
|
||||
debug_stop always project_host bindings async
|
||||
debug_threads trusted project_host bindings async
|
||||
debug_unity_processes trusted project_host bindings async
|
||||
debug_variables trusted project_host bindings async
|
||||
dependency_versions trusted project_host bindings async
|
||||
deploy_compare trusted project_host bindings async
|
||||
|
||||
+2
-1
@@ -1337,6 +1337,7 @@ export const commands = {
|
||||
debugAttachableProcesses: () => typedError<AttachableProcess[], IdeError>(__TAURI_INVOKE("debug_attachable_processes")),
|
||||
/** A loopback port that is free right now, for a debug agent the launch line starts. */
|
||||
debugFreePort: () => typedError<number, IdeError>(__TAURI_INVOKE("debug_free_port")),
|
||||
debugUnityProcesses: () => typedError<AttachableProcess[], IdeError>(__TAURI_INVOKE("debug_unity_processes")),
|
||||
/**
|
||||
* Remote JVM Debug in listen mode: waits (cancellable through `request`) for the remote
|
||||
* JVM to connect to `host:port`; returns the loopback port java-debug attaches to.
|
||||
@@ -2737,7 +2738,7 @@ export type AskpassKind =
|
||||
/** Yes / no (an unknown host key); answered with `yes` or `no`. */
|
||||
"confirm";
|
||||
|
||||
export type AttachKind = "java" | "node" | "python" | "dotnet" | "go" | "native";
|
||||
export type AttachKind = "unity" | "java" | "node" | "python" | "dotnet" | "go" | "native";
|
||||
|
||||
export type AttachableProcess = {
|
||||
pid: number,
|
||||
|
||||
@@ -20,6 +20,7 @@ const proc = (p: Partial<AttachableProcess> & Pick<AttachableProcess, "pid" | "k
|
||||
name: p.kind,
|
||||
commandLine: `${p.kind} app`,
|
||||
adapter: {
|
||||
unity: "unity",
|
||||
java: "java-debug",
|
||||
node: "js-debug",
|
||||
python: "debugpy",
|
||||
@@ -49,6 +50,14 @@ const list = [
|
||||
];
|
||||
|
||||
describe("Attach to Process popup model", () => {
|
||||
it("attaches the chosen Unity Editor by its exact ID without launching or using a native adapter", async () => {
|
||||
const launch = await attachConfig(proc({ pid: 1234, kind: "unity", name: "Unity Editor" }), "/game");
|
||||
expect(launch).toMatchObject({ adapter: "unity", request: "attach", program: null, cwd: "/game" });
|
||||
expect(JSON.parse(launch.extraJson!)).toEqual({
|
||||
name: "Unity Editor (1234)",
|
||||
__exceptionOptions: [],
|
||||
});
|
||||
});
|
||||
it("groups processes by debugger in IDEA's order with counts", () => {
|
||||
const rows = attachRows(list, "");
|
||||
expect(rows.filter((r) => r.kind === "group").map((r) => r.kind === "group" && `${r.label}:${r.count}`)).toEqual([
|
||||
|
||||
@@ -12,6 +12,7 @@ describe("missing debug adapters", () => {
|
||||
});
|
||||
|
||||
it("offers the managed install of a missing adapter binary", () => {
|
||||
expect(missingAdapter("unity", unavailable("debug adapter `unity` not found"))?.tool).toBe("unity-debug");
|
||||
const e = unavailable(
|
||||
"debug adapter `js-debug` not found (`js-debug-adapter` is neither installed by OpenIDEA nor on PATH)",
|
||||
);
|
||||
|
||||
@@ -0,0 +1,142 @@
|
||||
import { afterEach, beforeEach, expect, it, vi } from "vitest";
|
||||
import { act, cleanup, fireEvent, render, screen, waitFor } from "@testing-library/react";
|
||||
import type { AttachableProcess, ProjectInfo, RunConfig } from "@/platform/ipc";
|
||||
|
||||
const mocks = vi.hoisted(() => ({ discover: vi.fn(), generic: vi.fn(), start: vi.fn(), install: vi.fn() }));
|
||||
vi.mock("@/platform/ipc", async (original) => {
|
||||
const real = await original<typeof import("@/platform/ipc")>();
|
||||
return {
|
||||
...real,
|
||||
isTauri: () => true,
|
||||
commands: {
|
||||
...real.commands,
|
||||
debugUnityProcesses: mocks.discover,
|
||||
debugAttachableProcesses: mocks.generic,
|
||||
},
|
||||
};
|
||||
});
|
||||
vi.mock("../state", async (original) => ({
|
||||
...(await original<typeof import("../state")>()),
|
||||
startSession: mocks.start,
|
||||
}));
|
||||
|
||||
import { registerAction } from "@/platform/actions";
|
||||
import { useProject } from "@/platform/project";
|
||||
import { openAttachPopup, installAttachAdapter } from "../attachPopup";
|
||||
import { DebuggerOverlays } from "../ui/Overlays";
|
||||
import { useOverlays } from "../ui/popoverStore";
|
||||
|
||||
const editor: AttachableProcess = {
|
||||
pid: 42,
|
||||
name: "Unity Editor",
|
||||
commandLine: "/game",
|
||||
adapter: "unity",
|
||||
kind: "unity",
|
||||
host: null,
|
||||
port: null,
|
||||
};
|
||||
const ok = (data: AttachableProcess[]) => ({ status: "ok" as const, data });
|
||||
function deferred() {
|
||||
let resolve!: (result: ReturnType<typeof ok>) => void;
|
||||
const promise = new Promise<ReturnType<typeof ok>>((r) => {
|
||||
resolve = r;
|
||||
});
|
||||
return { promise, resolve };
|
||||
}
|
||||
let dispose: () => void;
|
||||
beforeEach(() => {
|
||||
vi.clearAllMocks();
|
||||
useProject.setState({ project: { root: "/game" } as ProjectInfo });
|
||||
useOverlays.setState({ attach: null });
|
||||
mocks.discover.mockResolvedValue(ok([editor]));
|
||||
mocks.start.mockResolvedValue(1);
|
||||
mocks.install.mockResolvedValue(undefined);
|
||||
dispose = registerAction({ id: "tools.install", title: "Install", run: mocks.install });
|
||||
});
|
||||
afterEach(() => {
|
||||
cleanup();
|
||||
dispose();
|
||||
useOverlays.setState({ attach: null });
|
||||
useProject.setState({ project: null });
|
||||
});
|
||||
|
||||
it("selects the requested Unity process and starts a non-rerunnable attach session", async () => {
|
||||
const otherEditor = { ...editor, pid: 84, commandLine: "/other-game" };
|
||||
mocks.discover.mockResolvedValueOnce(ok([otherEditor, editor]));
|
||||
await openAttachPopup("unity");
|
||||
render(<DebuggerOverlays />);
|
||||
expect(screen.getByRole("dialog", { name: "Attach to Unity Process" })).toBeTruthy();
|
||||
expect(screen.getByText(/switch to Debug Mode/)).toBeTruthy();
|
||||
fireEvent.keyDown(screen.getByRole("textbox", { name: "Filter processes" }), { key: "ArrowDown" });
|
||||
fireEvent.click(screen.getByRole("button", { name: "Attach" }));
|
||||
await waitFor(() =>
|
||||
expect(mocks.start).toHaveBeenCalledWith(
|
||||
expect.objectContaining({
|
||||
request: "attach",
|
||||
adapter: "unity",
|
||||
cwd: "/game",
|
||||
extraJson: expect.stringContaining("Unity Editor (42)"),
|
||||
}),
|
||||
{ rerunnable: false },
|
||||
),
|
||||
);
|
||||
expect(mocks.generic).not.toHaveBeenCalled();
|
||||
expect(useOverlays.getState().attach).toBeNull();
|
||||
});
|
||||
|
||||
it("associates the selected run configuration after refreshing the picker", async () => {
|
||||
const runConfig = { id: "unity-editor", name: "Unity Editor", kind: "unity-editor" } as RunConfig;
|
||||
await openAttachPopup("unity", runConfig);
|
||||
render(<DebuggerOverlays />);
|
||||
fireEvent.click(screen.getByRole("button", { name: "Refresh" }));
|
||||
await waitFor(() => expect(useOverlays.getState().attach?.processes).toEqual([editor]));
|
||||
fireEvent.click(screen.getByRole("button", { name: "Attach" }));
|
||||
await waitFor(() => expect(mocks.start).toHaveBeenCalledWith(expect.anything(), { rerunnable: false, runConfig }));
|
||||
});
|
||||
|
||||
it("offers installation for a missing adapter and retries discovery afterwards", async () => {
|
||||
mocks.discover.mockResolvedValueOnce({
|
||||
status: "error",
|
||||
error: { kind: "unavailable", message: "debug adapter `unity` not found" },
|
||||
});
|
||||
await openAttachPopup("unity");
|
||||
render(<DebuggerOverlays />);
|
||||
fireEvent.click(screen.getByRole("button", { name: "Install Unity Debugger" }));
|
||||
await waitFor(() => expect(useOverlays.getState().attach?.processes).toEqual([editor]));
|
||||
expect(mocks.install).toHaveBeenCalledWith(expect.objectContaining({ arg: "unity-debug" }));
|
||||
});
|
||||
|
||||
it("does not replace a refreshed picker with an older discovery response", async () => {
|
||||
const old = deferred();
|
||||
mocks.discover.mockReturnValueOnce(old.promise);
|
||||
const first = openAttachPopup("unity");
|
||||
await openAttachPopup("unity");
|
||||
old.resolve(ok([]));
|
||||
await first;
|
||||
expect(useOverlays.getState().attach?.processes).toEqual([editor]);
|
||||
});
|
||||
|
||||
it("does not reopen a cancelled picker when discovery finishes", async () => {
|
||||
const pending = deferred();
|
||||
mocks.discover.mockReturnValueOnce(pending.promise);
|
||||
const request = openAttachPopup("unity");
|
||||
useOverlays.setState({ attach: null });
|
||||
pending.resolve(ok([editor]));
|
||||
await request;
|
||||
expect(useOverlays.getState().attach).toBeNull();
|
||||
});
|
||||
|
||||
it("does not attach to an old project's process or retry installation after switching projects", async () => {
|
||||
await openAttachPopup("unity");
|
||||
render(<DebuggerOverlays />);
|
||||
act(() => useProject.setState({ project: { root: "/other" } as ProjectInfo }));
|
||||
fireEvent.click(screen.getByRole("button", { name: "Attach" }));
|
||||
expect(mocks.start).not.toHaveBeenCalled();
|
||||
act(() =>
|
||||
useOverlays.setState({
|
||||
attach: { processes: [], error: "missing", mode: "unity", projectRoot: "/game", installTool: "unity-debug" },
|
||||
}),
|
||||
);
|
||||
await installAttachAdapter();
|
||||
expect(mocks.discover).toHaveBeenCalledTimes(1);
|
||||
});
|
||||
@@ -80,14 +80,10 @@ import { expressionAt, valueHint } from "./editor/valueTooltip";
|
||||
import { mouseEvaluateTarget } from "./editor/quickEvaluate";
|
||||
import { showHint } from "@/editor/lsp/hint";
|
||||
import { pausedLineTargets, startInlineSmartStep } from "./editor/smartStep";
|
||||
import {
|
||||
openBreakpointsDialog,
|
||||
openConfigChooser,
|
||||
openEvaluateDialog,
|
||||
openSmartStepChooser,
|
||||
useOverlays,
|
||||
} from "./ui/popoverStore";
|
||||
import { openBreakpointsDialog, openConfigChooser, openEvaluateDialog, openSmartStepChooser } from "./ui/popoverStore";
|
||||
import { tx } from "@/platform/i18n";
|
||||
import { openAttachPopup } from "./attachPopup";
|
||||
export { openAttachPopup } from "./attachPopup";
|
||||
|
||||
function isRunConfig(arg: unknown): arg is RunConfig {
|
||||
return !!arg && typeof arg === "object" && "command" in arg && "args" in arg && "debugAdapter" in arg;
|
||||
@@ -180,22 +176,6 @@ async function smartStepInto() {
|
||||
if (!startInlineSmartStep(t.s.id, t.thread, targets)) openSmartStepChooser(t.s.id, t.thread, targets);
|
||||
}
|
||||
|
||||
/** Opens the Attach to Process popup and loads the process list. */
|
||||
export async function openAttachPopup() {
|
||||
if (!isTauri()) {
|
||||
notifications().notify({ group: "run", level: "warning", title: "Attaching needs the desktop app" });
|
||||
return;
|
||||
}
|
||||
useOverlays.setState({ attach: { processes: null, error: null } });
|
||||
try {
|
||||
const processes = await call(commands.debugAttachableProcesses());
|
||||
if (useOverlays.getState().attach) useOverlays.setState({ attach: { processes, error: null } });
|
||||
} catch (e) {
|
||||
if (useOverlays.getState().attach)
|
||||
useOverlays.setState({ attach: { processes: [], error: errorText(e) || "Cannot list processes" } });
|
||||
}
|
||||
}
|
||||
|
||||
function cursor(): { path: string; line: number; selection: string } | null {
|
||||
const ed = activeEditor();
|
||||
if (!ed) return null;
|
||||
@@ -891,6 +871,15 @@ export function registerDebugActions(): () => void {
|
||||
description: "Attach the debugger to a running Java, Node.js, Python, Go or native process",
|
||||
run: () => void openAttachPopup(),
|
||||
},
|
||||
{
|
||||
id: "debug.attachUnity",
|
||||
title: "Attach to Unity Process",
|
||||
category: "Run",
|
||||
icon: "debug",
|
||||
hidden: true,
|
||||
when: "projectOpen",
|
||||
run: ({ arg }) => openAttachPopup("unity", arg as RunConfig | undefined),
|
||||
},
|
||||
{
|
||||
id: "debug.debugInBrowser",
|
||||
title: "Debug in Browser",
|
||||
|
||||
@@ -7,6 +7,7 @@ import type { AttachKind, AttachableProcess, LaunchConfig } from "@/platform/ipc
|
||||
import { javaAttachConfig } from "./java";
|
||||
|
||||
export const KIND_LABELS: Record<AttachKind, string> = {
|
||||
unity: "Unity Editor",
|
||||
java: "Java (JDWP)",
|
||||
node: "Node.js",
|
||||
python: "Python (debugpy)",
|
||||
@@ -15,7 +16,7 @@ export const KIND_LABELS: Record<AttachKind, string> = {
|
||||
native: "Native (LLDB)",
|
||||
};
|
||||
|
||||
const KIND_ORDER: AttachKind[] = ["java", "node", "python", "dotnet", "go", "native"];
|
||||
const KIND_ORDER: AttachKind[] = ["unity", "java", "node", "python", "dotnet", "go", "native"];
|
||||
|
||||
export type AttachRow =
|
||||
| { kind: "group"; key: string; label: string; count: number }
|
||||
@@ -64,6 +65,14 @@ function base(p: AttachableProcess, cwd: string, extra: Record<string, unknown>)
|
||||
export async function attachConfig(p: AttachableProcess, root: string): Promise<LaunchConfig> {
|
||||
const skip = workflowSettings().debugger.skipLibraryCode;
|
||||
switch (p.kind) {
|
||||
case "unity":
|
||||
return {
|
||||
...base(p, root, {
|
||||
name: `Unity Editor (${p.pid})`,
|
||||
__exceptionOptions: [],
|
||||
}),
|
||||
adapter: "unity",
|
||||
};
|
||||
case "java":
|
||||
return javaAttachConfig(
|
||||
{ name: `${p.name} (${p.pid})`, module: "", hostName: p.host ?? "localhost", port: p.port! },
|
||||
|
||||
@@ -0,0 +1,44 @@
|
||||
import { executeAction } from "@/platform/actions";
|
||||
import { call, commands, isTauri, type RunConfig } from "@/platform/ipc";
|
||||
import { useProject } from "@/platform/project";
|
||||
import { notifications } from "@/workbench/contributions";
|
||||
import { missingAdapter } from "./missingAdapter";
|
||||
import { useOverlays } from "./ui/popoverStore";
|
||||
|
||||
/** Applies only the latest request of the open popup; results for a closed or refreshed one are dropped. */
|
||||
export async function openAttachPopup(mode: "all" | "unity" = "all", runConfig?: RunConfig) {
|
||||
if (!isTauri()) {
|
||||
notifications().notify({ group: "run", level: "warning", title: "Attaching needs the desktop app" });
|
||||
return;
|
||||
}
|
||||
const projectRoot = useProject.getState().project?.root ?? null;
|
||||
const pending = { processes: null, error: null, mode, projectRoot, runConfig };
|
||||
useOverlays.setState({ attach: pending });
|
||||
const current = () =>
|
||||
useOverlays.getState().attach === pending && (useProject.getState().project?.root ?? null) === projectRoot;
|
||||
try {
|
||||
const processes = await call(
|
||||
mode === "unity" ? commands.debugUnityProcesses() : commands.debugAttachableProcesses(),
|
||||
);
|
||||
if (current()) useOverlays.setState({ attach: { ...pending, processes } });
|
||||
} catch (e) {
|
||||
if (current())
|
||||
useOverlays.setState({
|
||||
attach: {
|
||||
...pending,
|
||||
processes: [],
|
||||
error: e instanceof Error ? e.message : String(e),
|
||||
installTool: mode === "unity" ? missingAdapter("unity", e)?.tool : undefined,
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
export async function installAttachAdapter() {
|
||||
const state = useOverlays.getState().attach;
|
||||
if (!state?.installTool) return;
|
||||
await executeAction("tools.install", state.installTool);
|
||||
if (useOverlays.getState().attach === state && useProject.getState().project?.root === state.projectRoot) {
|
||||
await openAttachPopup(state.mode, state.runConfig);
|
||||
}
|
||||
}
|
||||
@@ -145,6 +145,7 @@ export function activate(): () => void {
|
||||
useProject.subscribe((s, prev) => {
|
||||
const root = s.project?.root ?? null;
|
||||
if (root !== (prev.project?.root ?? null) || s.project?.trusted !== prev.project?.trusted) {
|
||||
useOverlays.setState({ attach: null });
|
||||
resetSessions();
|
||||
loadWatches(root);
|
||||
loadBreakpoints(root);
|
||||
|
||||
@@ -8,6 +8,7 @@ import { tx } from "@/platform/i18n";
|
||||
|
||||
/** Adapters the tools installer can provide (adapter id → tool name). */
|
||||
const INSTALLABLE: Record<string, { tool: string; title: string }> = {
|
||||
unity: { tool: "unity-debug", title: "Unity Debugger is not installed" },
|
||||
"kotlin-debug-adapter": { tool: "kotlin-debug-adapter", title: "The Kotlin debugger is not installed" },
|
||||
netcoredbg: { tool: "netcoredbg", title: "netcoredbg is not installed" },
|
||||
debugpy: { tool: "debugpy", title: "debugpy is not installed" },
|
||||
|
||||
@@ -33,6 +33,7 @@ import {
|
||||
type SpecialBreakpoint,
|
||||
} from "../breakpoints/special";
|
||||
import { attachConfig, attachDetail, attachRows, type AttachRow } from "../attach";
|
||||
import { openAttachPopup, installAttachAdapter } from "../attachPopup";
|
||||
import {
|
||||
exceptionGroups,
|
||||
filterHint,
|
||||
@@ -915,6 +916,7 @@ function AttachPopup() {
|
||||
const root = useProject((s) => s.project?.root ?? null);
|
||||
const [filter, setFilter] = useState("");
|
||||
const [active, setActive] = useState(0);
|
||||
const [installing, setInstalling] = useState(false);
|
||||
const rows = useMemo(() => attachRows(state?.processes ?? [], filter), [state?.processes, filter]);
|
||||
const firstItem = rows.findIndex((r) => r.kind === "process");
|
||||
const activeIndex = rows[active]?.kind === "process" ? active : firstItem;
|
||||
@@ -925,10 +927,11 @@ function AttachPopup() {
|
||||
useOverlays.setState({ attach: null });
|
||||
};
|
||||
const attach = async (p: AttachableProcess) => {
|
||||
if (state.projectRoot !== undefined && state.projectRoot !== root) return close();
|
||||
close();
|
||||
if (!root) return;
|
||||
try {
|
||||
await startSession(await attachConfig(p, root), { rerunnable: false });
|
||||
await startSession(await attachConfig(p, root), { rerunnable: false, runConfig: state.runConfig });
|
||||
} catch (e) {
|
||||
notifications().notify({
|
||||
group: "run",
|
||||
@@ -948,8 +951,44 @@ function AttachPopup() {
|
||||
}
|
||||
};
|
||||
return (
|
||||
<Dialog open onClose={close} title="Attach to Process" width={640} position="top" aria-label="Attach to process">
|
||||
<Dialog
|
||||
open
|
||||
onClose={close}
|
||||
title={state.mode === "unity" ? "Attach to Unity Process" : "Attach to Process"}
|
||||
width={640}
|
||||
position="top"
|
||||
aria-label={state.mode === "unity" ? "Attach to Unity Process" : "Attach to process"}
|
||||
buttons={[
|
||||
{
|
||||
label: "Refresh",
|
||||
role: "extra",
|
||||
disabled: state.processes === null || installing,
|
||||
onClick: () => {
|
||||
setActive(0);
|
||||
void openAttachPopup(state.mode, state.runConfig);
|
||||
},
|
||||
},
|
||||
{ label: "Cancel", role: "cancel", onClick: close },
|
||||
{
|
||||
label: "Attach",
|
||||
role: "default",
|
||||
disabled: rows[activeIndex]?.kind !== "process" || installing,
|
||||
onClick: () => {
|
||||
const row = rows[activeIndex];
|
||||
if (row?.kind === "process") void attach(row.process);
|
||||
},
|
||||
},
|
||||
]}
|
||||
>
|
||||
<div className={styles.evalBody}>
|
||||
{state.mode === "unity" && (
|
||||
<p>
|
||||
<T>
|
||||
Open the project in Unity Editor, enable Editor Attaching and switch to Debug Mode. Select its process
|
||||
below. Stopping debugging disconnects without closing Unity.
|
||||
</T>
|
||||
</p>
|
||||
)}
|
||||
<Input
|
||||
value={filter}
|
||||
onChange={(e) => {
|
||||
@@ -975,7 +1014,20 @@ function AttachPopup() {
|
||||
<T>Loading processes…</T>
|
||||
</div>
|
||||
) : state.error ? (
|
||||
<div className={styles.empty}>{state.error}</div>
|
||||
<div className={styles.empty}>
|
||||
<div>{state.error}</div>
|
||||
{state.installTool && (
|
||||
<Button
|
||||
disabled={installing}
|
||||
onClick={() => {
|
||||
setInstalling(true);
|
||||
void installAttachAdapter().finally(() => setInstalling(false));
|
||||
}}
|
||||
>
|
||||
{installing ? "Installing…" : "Install Unity Debugger"}
|
||||
</Button>
|
||||
)}
|
||||
</div>
|
||||
) : (
|
||||
<List<AttachRow>
|
||||
items={rows}
|
||||
@@ -996,7 +1048,11 @@ function AttachPopup() {
|
||||
className={styles.attachList}
|
||||
empty={
|
||||
<div className={styles.empty}>
|
||||
{filter ? tx`No attachable processes match the filter.` : tx`No attachable processes.`}
|
||||
{filter
|
||||
? tx`No attachable processes match the filter.`
|
||||
: state.mode === "unity"
|
||||
? tx`No Unity Editor processes found. Open Unity Editor, then refresh.`
|
||||
: tx`No attachable processes.`}
|
||||
</div>
|
||||
}
|
||||
renderItem={(r) =>
|
||||
|
||||
@@ -15,7 +15,14 @@ interface OverlayState {
|
||||
breakpoints: { path?: string; id?: string } | null;
|
||||
chooser: { configs: RunConfig[] } | null;
|
||||
/** Attach to Process popup; `processes` is null while loading. */
|
||||
attach: { processes: AttachableProcess[] | null; error: string | null } | null;
|
||||
attach: {
|
||||
processes: AttachableProcess[] | null;
|
||||
error: string | null;
|
||||
mode?: "all" | "unity";
|
||||
projectRoot?: string | null;
|
||||
installTool?: string;
|
||||
runConfig?: RunConfig;
|
||||
} | null;
|
||||
/**
|
||||
* Smart Step Into: picked in the editor when `inline` is set (targets sorted
|
||||
* by position, `index` the selected one), else in the chooser dialog.
|
||||
|
||||
@@ -1,8 +1,8 @@
|
||||
import { afterEach, beforeEach, expect, it, vi } from "vitest";
|
||||
import { act, cleanup, fireEvent, render, screen } from "@testing-library/react";
|
||||
import { executeAction, executeActionFrom, getAction, registerAction } from "@/platform/actions";
|
||||
import { executeAction, executeActionFrom, getAction, isActionEnabled, registerAction } from "@/platform/actions";
|
||||
import { setContext } from "@/platform/context";
|
||||
import type { RunConfig } from "@/platform/ipc";
|
||||
import type { ProjectInfo, RunConfig } from "@/platform/ipc";
|
||||
import {
|
||||
registerMenuGroup,
|
||||
registerRunConfigType,
|
||||
@@ -10,6 +10,7 @@ import {
|
||||
type DebugRunSession,
|
||||
} from "@/workbench/contributions";
|
||||
import { useContextMenuStore } from "@/ui";
|
||||
import { useProject } from "@/platform/project";
|
||||
import { applicationConfig } from "./application";
|
||||
import { activate } from "./index";
|
||||
import { RunWidget } from "./RunWidget";
|
||||
@@ -52,6 +53,7 @@ const debug = (c: RunConfig, startedAt = 2): DebugRunSession => ({
|
||||
});
|
||||
let dispose: () => void;
|
||||
beforeEach(() => {
|
||||
useProject.setState({ project: null });
|
||||
resetRuns();
|
||||
useRun.setState({ configs: [app, npm], selectedId: app.id, loaded: true });
|
||||
useDebugRunSessions.setState({ sessions: [] });
|
||||
@@ -61,9 +63,51 @@ beforeEach(() => {
|
||||
afterEach(() => {
|
||||
cleanup();
|
||||
dispose();
|
||||
useProject.setState({ project: null });
|
||||
useDebugRunSessions.setState({ sessions: [] });
|
||||
});
|
||||
|
||||
function openUnity() {
|
||||
useProject.setState({
|
||||
project: {
|
||||
root: "/game",
|
||||
name: "Game",
|
||||
trusted: true,
|
||||
isGit: false,
|
||||
settings: {} as ProjectInfo["settings"],
|
||||
unity: { editorVersion: "6000.0.1f1", projects: [], solutions: [] },
|
||||
},
|
||||
});
|
||||
}
|
||||
|
||||
it("keeps other configurations available in a Unity project", () => {
|
||||
openUnity();
|
||||
useRun.setState({ configs: [app, npm], selectedId: app.id, loaded: true });
|
||||
render(<RunWidget />);
|
||||
expect(screen.getByRole("button", { name: `Run '${app.name}'` })).toBeEnabled();
|
||||
expect(isActionEnabled(getAction("run.run")!)).toBe(true);
|
||||
expect(isActionEnabled(getAction("run.chooseConfig")!)).toBe(true);
|
||||
});
|
||||
|
||||
it("attaches when the Unity configuration is debugged", async () => {
|
||||
openUnity();
|
||||
const unity = { ...config("unity-editor"), name: "Unity Editor", kind: "unity-editor", command: "" };
|
||||
useRun.setState({ configs: [unity, app], selectedId: unity.id, loaded: true });
|
||||
const attach = vi.fn();
|
||||
const unregister = registerAction({ id: "debug.attachUnity", title: "Attach", run: attach });
|
||||
try {
|
||||
render(<RunWidget />);
|
||||
expect(screen.getByRole("button", { name: `'${unity.name}' can only be debugged` })).toBeDisabled();
|
||||
await act(async () => {
|
||||
await executeAction("run.debug");
|
||||
});
|
||||
expect(attach).toHaveBeenCalledOnce();
|
||||
expect(useRun.getState().configs).toContain(app);
|
||||
} finally {
|
||||
unregister();
|
||||
}
|
||||
});
|
||||
|
||||
it("reruns and stops the selected configuration among several running sessions", () => {
|
||||
useRun.setState({ sessions: [run(app), run(npm, 3)] });
|
||||
render(<RunWidget />);
|
||||
|
||||
@@ -67,6 +67,32 @@ it("lists pinned configurations first, in pin order, and not again in their grou
|
||||
expect(names(buildRows(configs, "s", null, [], ["serve"]))).toEqual(["[Pinned]", "serve", "---", "edit"]);
|
||||
});
|
||||
|
||||
it("adds and selects a Unity attach configuration without hiding other configurations", async () => {
|
||||
useProject.setState({ project: { root: "/pinned", unity: {} } as never });
|
||||
await loadConfigs();
|
||||
expect(useRun.getState().configs.map((c) => c.id)).toEqual(["build", "serve", "App", "unity-editor"]);
|
||||
expect(useRun.getState().selectedId).toBe("unity-editor");
|
||||
await loadConfigs();
|
||||
expect(useRun.getState().configs.filter((c) => c.kind === "unity-editor")).toHaveLength(1);
|
||||
});
|
||||
|
||||
it("keeps a configuration whose id collides with the Unity default", async () => {
|
||||
useProject.setState({ project: { root: "/pinned", unity: {} } as never });
|
||||
ipc.runConfigs.mockResolvedValue({ status: "ok", data: [config("unity-editor")] });
|
||||
await loadConfigs();
|
||||
expect(useRun.getState().configs.map((c) => c.id)).toEqual(["unity-editor", "unity-editor-attach"]);
|
||||
expect(useRun.getState().selectedId).toBe("unity-editor-attach");
|
||||
});
|
||||
|
||||
it("retains a saved Unity configuration and selected configuration", async () => {
|
||||
useProject.setState({ project: { root: "/pinned", unity: {} } as never });
|
||||
ipc.runConfigs.mockResolvedValue({ status: "ok", data: [...configs, config("my-unity", "unity-editor")] });
|
||||
useRun.setState({ selectedId: "serve" });
|
||||
await loadConfigs();
|
||||
expect(useRun.getState().configs.filter((c) => c.kind === "unity-editor")).toHaveLength(1);
|
||||
expect(useRun.getState().selectedId).toBe("serve");
|
||||
});
|
||||
|
||||
it("keeps pins per project across reloads", async () => {
|
||||
await loadConfigs();
|
||||
togglePinned("serve");
|
||||
|
||||
@@ -104,6 +104,7 @@ import { TEST_TREE_FOCUS, testTree } from "./testTree";
|
||||
import { startAgentRun, trimAgentArchive, type AgentRunRequest } from "./agentRuns";
|
||||
import { compoundTargets, selectedTarget } from "./sessionTargets";
|
||||
import { tx } from "@/platform/i18n";
|
||||
import { UNITY_CONFIG_KIND, showUnityAttach } from "./unity";
|
||||
|
||||
function trackFailedTestSelection(): () => void {
|
||||
let signature = "";
|
||||
@@ -171,6 +172,7 @@ async function debugConfig(config: RunConfig, chain: readonly string[] = [], sho
|
||||
}
|
||||
if (remoteDebugBlocked(config)) return;
|
||||
if (!(await prepareLaunch(config, chain, show))) return;
|
||||
if (config.kind === UNITY_CONFIG_KIND) return showUnityAttach(config);
|
||||
// Python on a Docker / Compose target: debugpy in the container, the debugger attaches.
|
||||
if (containerDebuggable(config) && getAction("debug.attach")) {
|
||||
await debugInContainer(config);
|
||||
@@ -488,6 +490,14 @@ export function activate(): () => void {
|
||||
when: "projectOpen",
|
||||
run: () => debugSelected(),
|
||||
},
|
||||
{
|
||||
id: "run.attachUnity",
|
||||
title: "Attach to Unity Process",
|
||||
category: "Run",
|
||||
icon: "debug",
|
||||
when: "projectOpen",
|
||||
run: () => showUnityAttach(),
|
||||
},
|
||||
{
|
||||
id: "run.runContext",
|
||||
title: "Run Context Configuration",
|
||||
|
||||
@@ -65,6 +65,7 @@ import { tomcatBrowserUrl } from "./tomcat";
|
||||
import { gradleBootLaunch, gradleDelegation, gradleTestLaunch } from "./gradleRun";
|
||||
import { openUrl } from "./navigate";
|
||||
import { tx } from "@/platform/i18n";
|
||||
import { UNITY_CONFIG_KIND } from "./unity";
|
||||
|
||||
/** The permanent "Current File" pseudo-configuration of the chooser (runs the active file's context). */
|
||||
export const CURRENT_FILE = "current-file";
|
||||
@@ -240,11 +241,29 @@ export async function loadConfigs(): Promise<void> {
|
||||
const temps = kept.length ? await call(commands.runApplySettings(kept)).catch(() => kept) : kept;
|
||||
if (useProject.getState().project?.root !== root) return;
|
||||
const configs = [...saved, ...temps];
|
||||
if (useProject.getState().project?.unity && !configs.some((config) => config.kind === UNITY_CONFIG_KIND)) {
|
||||
let id = "unity-editor";
|
||||
while (configs.some((config) => config.id === id)) id += "-attach";
|
||||
configs.push({
|
||||
id,
|
||||
name: "Unity Editor",
|
||||
kind: UNITY_CONFIG_KIND,
|
||||
command: "",
|
||||
args: [],
|
||||
cwd: null,
|
||||
env: {},
|
||||
detected: true,
|
||||
isTest: false,
|
||||
debugAdapter: null,
|
||||
});
|
||||
}
|
||||
const stored = useRun.getState().selectedId ?? readSelected(root);
|
||||
const selectedId =
|
||||
stored === CURRENT_FILE || configs.some((c) => c.id === stored)
|
||||
? stored
|
||||
: (defaultSelection(saved)?.id ?? CURRENT_FILE);
|
||||
: (configs.find((config) => config.kind === UNITY_CONFIG_KIND)?.id ??
|
||||
defaultSelection(saved)?.id ??
|
||||
CURRENT_FILE);
|
||||
useRun.setState({
|
||||
configs,
|
||||
temporary: temps.map((t) => t.id),
|
||||
|
||||
@@ -28,6 +28,7 @@ import { dotnetProjectType, dotnetTestType } from "./dotnetTypes";
|
||||
import { rakeType, rspecType, rubyScriptType } from "./rubyTypes";
|
||||
import { djangoTestType } from "./djangoTypes";
|
||||
import { phpunitType } from "./phpunitTypes";
|
||||
import { UNITY_CONFIG_KIND } from "./unity";
|
||||
|
||||
export const COMPOUND = "compound";
|
||||
|
||||
@@ -475,6 +476,14 @@ const pytest: RunConfigTypeContribution = {
|
||||
};
|
||||
|
||||
export const BUILTIN_TYPES: readonly RunConfigTypeContribution[] = [
|
||||
{
|
||||
id: UNITY_CONFIG_KIND,
|
||||
label: "Unity Editor",
|
||||
icon: "attach-to-process",
|
||||
debugOnly: true,
|
||||
fields: [],
|
||||
commandLine: () => null,
|
||||
},
|
||||
shell,
|
||||
program,
|
||||
npm,
|
||||
|
||||
@@ -0,0 +1,13 @@
|
||||
import { executeAction, getAction } from "@/platform/actions";
|
||||
import type { RunConfig } from "@/platform/ipc";
|
||||
import { notifications } from "@/workbench/contributions";
|
||||
|
||||
export const UNITY_CONFIG_KIND = "unity-editor";
|
||||
|
||||
export async function showUnityAttach(config?: RunConfig): Promise<void> {
|
||||
if (!getAction("debug.attachUnity")) {
|
||||
notifications().notify({ group: "run", level: "warning", title: "Debugger is not available" });
|
||||
return;
|
||||
}
|
||||
await executeAction("debug.attachUnity", config);
|
||||
}
|
||||
@@ -1,4 +1,13 @@
|
||||
{
|
||||
"Unity Editor": "Unity Editor",
|
||||
"Attach to Unity Process": "Attach to Unity Process",
|
||||
"Open the project in Unity Editor, enable Editor Attaching and switch to Debug Mode. Select its process below. Stopping debugging disconnects without closing Unity.": "Open the project in Unity Editor, enable Editor Attaching and switch to Debug Mode. Select its process below. Stopping debugging disconnects without closing Unity.",
|
||||
"No Unity Editor processes found. Open Unity Editor, then refresh.": "No Unity Editor processes found. Open Unity Editor, then refresh.",
|
||||
"Install Unity Debugger": "Install Unity Debugger",
|
||||
"Unity Debugger is not installed": "Unity Debugger is not installed",
|
||||
"Debugger is not available": "Debugger is not available",
|
||||
"Attach": "Attach",
|
||||
"Installing…": "Installing…",
|
||||
"moved from {oldPath}": "moved from {oldPath}",
|
||||
"Symbolic link": "Symbolic link",
|
||||
"Copy as TSV": "Copy as TSV",
|
||||
|
||||
@@ -1,4 +1,12 @@
|
||||
{
|
||||
"Unity Editor": "Unity 编辑器",
|
||||
"Attach to Unity Process": "附加到 Unity 进程",
|
||||
"Open the project in Unity Editor, enable Editor Attaching and switch to Debug Mode. Select its process below. Stopping debugging disconnects without closing Unity.": "在 Unity 编辑器中打开项目,启用 Editor Attaching 并切换到 Debug Mode,然后在下方选择对应进程。停止调试会断开连接,Unity 编辑器会继续运行。",
|
||||
"No Unity Editor processes found. Open Unity Editor, then refresh.": "未找到 Unity 编辑器进程。打开 Unity 编辑器后刷新。",
|
||||
"Install Unity Debugger": "安装 Unity 调试器",
|
||||
"Unity Debugger is not installed": "尚未安装 Unity 调试器",
|
||||
"Attach": "附加",
|
||||
"Installing…": "正在安装…",
|
||||
"Symbolic link": "符号链接",
|
||||
"Copy as TSV": "复制为 TSV",
|
||||
"Copy as CSV": "复制为 CSV",
|
||||
|
||||
Reference in New Issue
Block a user