Skip to content

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.

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.ts
index 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 a
expect(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.ts
index 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;