The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
fix(go): resolve Delve targets with the selected compiler (#1997)
Shohruh Ismoilov5e7304a750aa
diff --git a/crates/ide-dap/src/lib.rs b/crates/ide-dap/src/lib.rsindex 23c8abcc0..2eda2474e 100644--- a/crates/ide-dap/src/lib.rs+++ b/crates/ide-dap/src/lib.rs@@ -746,6 +746,10 @@ impl DebugManager {{spec.env.push(("JAVA_HOME".into(), home));}+ // Delve looks up Go before applying the debuggee's launch environment.+ if config.adapter == "delve" {+ spec.env.extend(config.env.iter().map(|(key, value)| (key.clone(), value.clone())));+ }if config.adapter == "rdbg" {rdbg_command_line(&mut spec, &config, &cwd)?;}diff --git a/crates/ide-dap/src/tests.rs b/crates/ide-dap/src/tests.rsindex 908f997b6..6dc726732 100644--- a/crates/ide-dap/src/tests.rs+++ b/crates/ide-dap/src/tests.rs@@ -1040,6 +1040,39 @@ async fn connects_to_running_debug_server_over_tcp() {assert!(events.lock().iter().any(|e| matches!(e, IdeEvent::Debug { event: DebugEvent::Started { .. }, .. })));}+#[tokio::test]+async fn delve_adapter_inherits_the_selected_go_environment() {+ struct CaptureLauncher {+ inner: FakeLauncher,+ env: Arc<Mutex<Vec<(String, String)>>>,+ }+ impl AdapterLauncher for CaptureLauncher {+ fn launch(&self, spec: AdapterSpec, reuse: Option<u16>) -> LaunchFuture {+ *self.env.lock() = spec.env.clone();+ self.inner.launch(spec, reuse)+ }+ }+ let env = Arc::new(Mutex::new(Vec::new()));+ let launcher =+ CaptureLauncher { inner: FakeLauncher { log: Arc::default(), script: Script::default() }, env: env.clone() };+ let manager = DebugManager::with_launcher(Arc::new(LanguageRegistry::from_configs(Vec::new())), Arc::new(launcher));+ let (owner, _) = recording_owner("main");+ let config = LaunchConfig {+ name: "Go".into(),+ adapter: "delve".into(),+ request: "launch".into(),+ program: Some("/project".into()),+ args: vec![],+ cwd: None,+ env: BTreeMap::from([("PATH".into(), "/chosen/go/bin".into()), ("GOROOT".into(), "/chosen/go".into())]),+ extra_json: Some(json!({"mode":"debug"}).to_string()),+ };+ let id = manager.start(config, owner).await.unwrap();+ assert!(env.lock().contains(&("PATH".into(), "/chosen/go/bin".into())));+ assert!(env.lock().contains(&("GOROOT".into(), "/chosen/go".into())));+ manager.stop(id).await.unwrap();+}+/// Go Remote / Python remote: the adapter runs on another machine (`dlv --headless`,/// `debugpy --listen`); `debugServer: "host:port"` connects there instead of spawning one.#[tokio::test]diff --git a/crates/ide-host/src/ops/debug.rs b/crates/ide-host/src/ops/debug.rsindex d90d436cb..72b0e178b 100644--- a/crates/ide-host/src/ops/debug.rs+++ b/crates/ide-host/src/ops/debug.rs@@ -64,6 +64,7 @@ async fn debug_start_inner(let settings = settings.clone();config = host.blocking(move || {+ ide_sdk::go::prepare_debug_compiler(&mut config.env, &config.extra_json)?;ide_sdk::go::configure_environment(&root, &settings, &mut config.env);ide_sdk::go::apply_to_debug(&mut config.env,diff --git a/crates/ide-sdk/src/go.rs b/crates/ide-sdk/src/go.rsindex 34bc3d9a7..25a885161 100644--- a/crates/ide-sdk/src/go.rs+++ b/crates/ide-sdk/src/go.rs@@ -131,6 +131,117 @@ fn delve_build_flags(args: &[String], files: bool) -> Value {)}+/// An explicitly selected Go executable must also be the compiler Delve finds on PATH.+pub fn prepare_debug_compiler(+ env: &mut std::collections::BTreeMap<String, String>,+ extra_json: &Option<String>,+) -> ide_core::IdeResult<()> {+ #[cfg(windows)]+ for key in ["PATH", "GOROOT"] {+ if let Some(previous) = env.keys().find(|name| name.eq_ignore_ascii_case(key) && name.as_str() != key).cloned()+ {+ let value = env.remove(&previous).unwrap();+ env.entry(key.into()).or_insert(value);+ }+ }+ let extra: Value = extra_json.as_deref().and_then(|value| serde_json::from_str(value).ok()).unwrap_or_default();+ let Some(executable) = extra["__goExecutable"].as_str().filter(|value| *value != "go" && *value != "go.exe") else {+ return Ok(());+ };+ let path = env.get("PATH").map(std::ffi::OsString::from).unwrap_or_else(crate::exec::search_path);+ let executable = ide_core::process::find_executable(executable, &path)+ .ok_or_else(|| ide_core::IdeError::unavailable(format!("Go executable not found: {executable}")))?;+ if !executable.file_name().is_some_and(|name| {+ if cfg!(windows) {+ let name = name.to_string_lossy();+ name.eq_ignore_ascii_case("go") || name.eq_ignore_ascii_case("go.exe")+ } else {+ name == "go"+ }+ }) {+ return Err(ide_core::IdeError::invalid("Delve requires a Go SDK executable named go or go.exe"));+ }+ if !env.contains_key("GOROOT") {+ let mut command = std::process::Command::new(&executable);+ command.args(["env", "GOROOT"]).envs(env.iter());+ let goroot = crate::exec::query_command(command, std::time::Duration::from_secs(10))+ .ok_or_else(|| ide_core::IdeError::unavailable("Cannot query the selected Go SDK"))?;+ env.insert("GOROOT".into(), goroot);+ }+ let mut paths = vec![executable.parent().unwrap().to_path_buf()];+ paths.extend(std::env::split_paths(&path));+ let path = std::env::join_paths(paths).map_err(|error| ide_core::IdeError::invalid(error.to_string()))?;+ env.insert("PATH".into(), path.to_string_lossy().into_owned());+ Ok(())+}++fn resolve_debug_target(+ program: &mut Option<String>,+ env: &std::collections::BTreeMap<String, String>,+ extra: &mut Value,+ flags: &mut Vec<String>,+) -> ide_core::IdeResult<()> {+ let Some(targets) = extra.get("__goTargets") else { return Ok(()) };+ let targets: Vec<String> =+ serde_json::from_value(targets.clone()).map_err(|error| ide_core::IdeError::invalid(error.to_string()))?;+ let dir = extra["__goBuildDir"]+ .as_str()+ .map(std::path::Path::new)+ .ok_or_else(|| ide_core::IdeError::invalid("Go debug build directory is missing"))?;+ if targets.iter().any(|target| target.ends_with(".go")) {+ if !targets.iter().all(|target| target.ends_with(".go")) {+ return Err(ide_core::IdeError::invalid("Select Go source files or one package for debugging"));+ }+ let files: Vec<_> =+ targets.iter().map(|target| dunce::canonicalize(dir.join(target))).collect::<Result<_, _>>()?;+ let first = files.first().ok_or_else(|| ide_core::IdeError::invalid("Go debug target is missing"))?;+ if files.iter().any(|file| file.parent() != first.parent()) {+ return Err(ide_core::IdeError::invalid("Go source files must be in the same directory"));+ }+ *program = Some(first.to_string_lossy().into_owned());+ flags.extend(files.iter().skip(1).map(|file| file.to_string_lossy().into_owned()));+ extra["__goSourceArgs"] = json!(true);+ return Ok(());+ }+ let path = env.get("PATH").map(std::ffi::OsString::from).unwrap_or_else(crate::exec::search_path);+ let go = ide_core::process::find_executable("go", &path)+ .ok_or_else(|| ide_core::IdeError::unavailable("Go executable not found"))?;+ let mut command = std::process::Command::new(go);+ command.args(["list", "-find", "-f", "{{.Dir}}"]).current_dir(dir).envs(env.iter());+ let mut args = flags.iter();+ while let Some(flag) = args.next() {+ let name = flag.split('=').next().unwrap_or(flag);+ if ["-tags", "-mod", "-modfile", "-overlay", "-compiler"].contains(&name) {+ command.arg(flag);+ if name == flag+ && let Some(value) = args.next()+ {+ command.arg(value);+ }+ } else if ["-race", "-msan", "-asan"].contains(&name) {+ command.arg(flag);+ }+ }+ command.args(&targets);+ let output = crate::exec::query_command(command, std::time::Duration::from_secs(10)).ok_or_else(|| {+ ide_core::IdeError::invalid(format!(+ "Cannot resolve Go debug target: {}. Check its module path and build flags.",+ targets.join(" ")+ ))+ })?;+ let mut dirs: Vec<_> = output.lines().filter(|line| !line.trim().is_empty()).collect();+ dirs.sort();+ dirs.dedup();+ if dirs.len() != 1 {+ return Err(ide_core::IdeError::invalid(format!(+ "Go debugging requires one package; this target selects {}. Select a package or test instead.",+ dirs.len()+ )));+ }+ *program = Some(dirs[0].to_owned());+ Ok(())+}+pub fn apply_to_debug(env: &mut std::collections::BTreeMap<String, String>,program: &mut Option<String>,@@ -170,6 +281,7 @@ pub fn apply_to_debug(.collect::<Vec<_>>();merge_flags(&mut args, &flags);}+ resolve_debug_target(program, env, &mut extra, &mut args)?;if let Some(files) = extra.get("__goFiles").and_then(Value::as_array) {if extra["mode"] == "test" {if let Some(file) = files.first().and_then(Value::as_str).map(std::path::Path::new) {@@ -190,7 +302,10 @@ pub fn apply_to_debug(}// Delve appends its -o after array build flags; positional source files// require the string form so all compiler flags precede the file list.- extra["buildFlags"] = delve_build_flags(&args, extra.get("__goFiles").is_some() && extra["mode"] != "test");+ extra["buildFlags"] = delve_build_flags(+ &args,+ (extra.get("__goFiles").is_some() && extra["mode"] != "test") || extra["__goSourceArgs"] == true,+ );}if let Some(output) = extra.get("output").and_then(Value::as_str).and_then(|p| std::path::Path::new(p).parent()) {std::fs::create_dir_all(output)?;@@ -199,6 +314,10 @@ pub fn apply_to_debug(map.remove("__goUseTags");map.remove("__goToolArgs");map.remove("__goFiles");+ map.remove("__goExecutable");+ map.remove("__goTargets");+ map.remove("__goBuildDir");+ map.remove("__goSourceArgs");}*extra_json = Some(extra.to_string());Ok(())@@ -209,6 +328,74 @@ mod command_tests {use super::*;use std::collections::BTreeMap;+ #[test]+ fn debug_targets_resolve_imports_and_reject_multiple_packages() {+ if crate::exec::which("go").is_none() {+ return;+ }+ let tmp = tempfile::tempdir().unwrap();+ let root = dunce::canonicalize(tmp.path()).unwrap();+ std::fs::write(root.join("go.mod"), "module example.com/debugtargets\ngo 1.22\n").unwrap();+ for name in ["a", "b"] {+ std::fs::create_dir(root.join(name)).unwrap();+ std::fs::write(root.join(name).join("lib.go"), "package p\nfunc Value() {}\n").unwrap();+ }+ let mut env = BTreeMap::from([("GOWORK".into(), "off".into())]);+ let launch = |target: &str| {+ Some(json!({"mode":"test", "__goToolArgs":[], "__goTargets":[target], "__goBuildDir":root}).to_string())+ };+ let mut program = None;+ let mut extra = launch("example.com/debugtargets/a");+ apply_to_debug(&mut env, &mut program, &mut Vec::new(), &mut extra, &GoBuildTags::default()).unwrap();+ assert_eq!(program.as_deref(), root.join("a").to_str());+ let value: Value = serde_json::from_str(extra.as_deref().unwrap()).unwrap();+ assert!(value.get("__goTargets").is_none());+ let error =+ apply_to_debug(&mut env, &mut program, &mut Vec::new(), &mut launch("./..."), &GoBuildTags::default())+ .unwrap_err();+ assert!(error.to_string().contains("requires one package"), "{error}");+ std::fs::write(root.join("main.go"), "package main\nfunc main(){helper()}\n").unwrap();+ std::fs::write(root.join("helper.go"), "package main\nfunc helper(){}\n").unwrap();+ let mut extra = Some(+ json!({"mode":"debug","__goBuildDir":root,"__goTargets":["main.go","helper.go"],"__goToolArgs":[]})+ .to_string(),+ );+ apply_to_debug(&mut env, &mut program, &mut Vec::new(), &mut extra, &GoBuildTags::default()).unwrap();+ assert_eq!(program.as_deref(), root.join("main.go").to_str());+ let value: Value = serde_json::from_str(extra.as_deref().unwrap()).unwrap();+ assert_eq!(+ value["buildFlags"],+ format!("'{}'", root.join("helper.go").to_string_lossy().replace('\\', "\\\\").replace('\'', "\\'"))+ );+ }++ #[cfg(windows)]+ #[test]+ fn compiler_selection_preserves_case_insensitive_windows_environment_keys() {+ let mut env =+ BTreeMap::from([("Path".into(), "explicit path".into()), ("GoRoot".into(), "explicit root".into())]);+ prepare_debug_compiler(&mut env, &None).unwrap();+ assert_eq!(env["PATH"], "explicit path");+ assert_eq!(env["GOROOT"], "explicit root");+ assert!(!env.contains_key("Path"));+ assert!(!env.contains_key("GoRoot"));+ }++ #[test]+ fn the_selected_go_compiler_precedes_the_existing_path() {+ let Some(go) = crate::exec::which("go") else {+ return;+ };+ let mut env = BTreeMap::from([("PATH".into(), "/unrelated".into())]);+ let extra = Some(json!({"__goExecutable":go}).to_string());+ prepare_debug_compiler(&mut env, &extra).unwrap();+ assert_eq!(std::env::split_paths(&env["PATH"]).next().as_deref(), go.parent());+ assert!(!env["GOROOT"].is_empty());+ env.insert("GOROOT".into(), "explicit".into());+ prepare_debug_compiler(&mut env, &extra).unwrap();+ assert_eq!(env["GOROOT"], "explicit");+ }+#[test]fn detected_go_runs_inherit_tags_only_for_commands_that_accept_build_flags() {let tags = GoBuildTags { custom: "integration".into(), ..Default::default() };diff --git a/src/features/debugger/__tests__/launch.test.ts b/src/features/debugger/__tests__/launch.test.tsindex 359664287..74030c111 100644--- a/src/features/debugger/__tests__/launch.test.ts+++ b/src/features/debugger/__tests__/launch.test.ts@@ -253,7 +253,13 @@ describe("run config → launch config", () => {it("delve: debug mode for run, test mode for test", () => {const run = launchConfigFor(rc({ kind: "go", command: "go", args: ["run", "."], debugAdapter: "delve" }), "/p")!;expect(run.program).toBe("/p");- expect(extra(run)).toEqual({ mode: "debug", __goToolArgs: [], __goUseTags: true });+ expect(extra(run)).toMatchObject({+ mode: "debug",+ __goTargets: ["."],+ __goExecutable: "go",+ __goToolArgs: [],+ __goUseTags: true,+ });const sub = launchConfigFor(rc({ kind: "go", command: "go", args: ["run", "./cmd/api"], debugAdapter: "delve" }),"/p",@@ -263,8 +269,8 @@ describe("run config → launch config", () => {rc({ kind: "go", command: "go", args: ["test", "./..."], debugAdapter: "delve" }),"/p",)!;- expect(extra(test)).toEqual({ mode: "test", __goToolArgs: [], __goUseTags: true });- expect(test.program).toBe("/p");+ expect(extra(test)).toMatchObject({ mode: "test", __goTargets: ["./..."], __goToolArgs: [], __goUseTags: true });+ expect(test.program).toBe("/p/...");// A gutter test / subtest: the package, and `-run` for the test binary.const one = launchConfigFor(rc({@@ -419,6 +425,50 @@ it("netcoredbg launches the evaluated DLL with resolved profile arguments, env aexpect(launchConfigFor({ ...c, params: {} }, "/repo")).toBeNull();});+describe("Go debug target resolution inputs", () => {+ it("preserves import paths and multiple source files for Go to resolve", () => {+ const imported = launchConfigFor(+ rc({ kind: "go", command: "/sdk/bin/go", args: ["test", "example.com/app/calc"], debugAdapter: "delve" }),+ "/p",+ )!;+ expect(imported.program).toBe("example.com/app/calc");+ expect(extra(imported)).toMatchObject({+ __goTargets: ["example.com/app/calc"],+ __goExecutable: "/sdk/bin/go",+ __goBuildDir: "/p",+ });+ const files = launchConfigFor(+ rc({ kind: "go", command: "go", args: ["run", "main.go", "helper.go", "hello"], debugAdapter: "delve" }),+ "/p",+ )!;+ expect(files.args).toEqual(["hello"]);+ expect(extra(files).__goTargets).toEqual(["main.go", "helper.go"]);+ const packages = launchConfigFor(+ rc({ kind: "go", command: "go", args: ["build", "./a", "./b"], debugAdapter: "delve" }),+ "/p",+ )!;+ expect(extra(packages).__goTargets).toEqual(["./a", "./b"]);+ });++ it("keeps a typed recursive package target and the module's selected compiler", () => {+ const launch = launchConfigFor(+ rc({+ kind: "go",+ command: "./sdk/bin/go",+ args: ["test", "./..."],+ debugAdapter: "delve",+ params: { goKind: "test", scope: "package", target: "./...", module: "backend" },+ }),+ "/p",+ )!;+ expect(extra(launch)).toMatchObject({+ __goTargets: ["./..."],+ __goBuildDir: "/p/backend",+ __goExecutable: "/p/backend/sdk/bin/go",+ });+ });+});+it("raw and typed Go debug configurations inherit custom tags unless explicitly disabled", () => {for (const typed of [false, true]) {for (const useTags of [undefined, "true", "false"]) {diff --git a/src/features/debugger/launch.ts b/src/features/debugger/launch.tsindex 1193277f5..681b7aca4 100644--- a/src/features/debugger/launch.ts+++ b/src/features/debugger/launch.ts@@ -16,7 +16,7 @@ function join(base: string, p: string) {/** A command path with a directory part resolved against `cwd`; bare names stay for PATH lookup. */function resolveCommand(cmd: string, cwd: string) {- return cmd.includes("/") ? join(cwd, cmd) : cmd;+ return /[\\/]/.test(cmd) ? join(cwd, cmd) : cmd;}function splitAtDashDash(args: readonly string[]): [string[], string[]] {@@ -225,6 +225,9 @@ function delveLaunch(rc: RunConfig, cwd: string, root: string): LaunchConfig {dlvCwd: module,...(p.scope === "file" ? { __goFiles: target.split("|").map((f) => join(module, f.trim())) } : {}),__goToolArgs: toolArgs,+ ...(p.scope === "file" ? {} : { __goTargets: [target] }),+ __goBuildDir: module,+ __goExecutable: resolveCommand(rc.command, module),__goUseTags: p.useTags !== "false",...(p.outputDir ? { output: join(root, `${p.outputDir}/go-debug`) } : {}),});@@ -261,9 +264,11 @@ function delveLaunch(rc: RunConfig, cwd: string, root: string): LaunchConfig {}const selection =test &&- /^-(run|skip|bench|benchtime|count|timeout|parallel|cpu|list|fuzz|fuzztime|fuzzminimizetime)(?:=(.*))?$/.exec(a);- if (test && /^-(short|failfast|benchmem|fullpath|v)(?:=|$)/.test(a)) {- testFlags.push(a.replace(/^-/, "-test."));+ /^-(?:test\.)?(run|skip|bench|benchtime|count|timeout|parallel|cpu|list|fuzz|fuzztime|fuzzminimizetime)(?:=(.*))?$/.exec(+ a,+ );+ if (test && /^-(?:test\.)?(short|failfast|benchmem|fullpath|v)(?:=|$)/.test(a)) {+ testFlags.push(a.startsWith("-test.") ? a : a.replace(/^-/, "-test."));} else if (selection) {const value = selection[2] ?? rest[++i];if (value !== undefined) testFlags.push(`-test.${selection[1]}`, value);@@ -271,18 +276,25 @@ function delveLaunch(rc: RunConfig, cwd: string, root: string): LaunchConfig {if (test && (a === "-json" || a === "-c")) continue;flags.push(a);if (!a.includes("=") && !boolFlags.has(a) && rest[i + 1] !== undefined) flags.push(rest[++i]!);- } else if (!test && targets.length) {+ } else if (+ sub === "run" &&+ targets.length &&+ !(a.endsWith(".go") && targets.every((target) => target.endsWith(".go")))+ ) {programArgs = rest.slice(i);break;} else targets.push(a);}const target = targets[0] ?? ".";- out.program = target.endsWith("/...") ? cwd : join(cwd, target);+ out.program = !target.startsWith(".") && !isAbsolute(target) && !target.endsWith(".go") ? target : join(cwd, target);out.args = [...testFlags, ...programArgs];out.extraJson = JSON.stringify({mode: test ? "test" : "debug",...(flags.length ? { buildFlags: formatArgs(flags) } : {}),__goToolArgs: flags,+ __goTargets: targets.length ? targets : ["."],+ __goBuildDir: cwd,+ __goExecutable: resolveCommand(rc.command, cwd),__goUseTags: rc.params?.useTags !== "false",});return out;