bug: Golang integration not woking

[daibertdiego]

Did you check docs and existing issues?

• I have read all the plugin docs
• I have searched the existing issues
• I have searched the existing issues of plugins related to this issue

Neovim version (nvim -v)

0.11.2

Operating system/version

MacOS 15.5

Describe the bug

I'm trying to integrate dap-view with golang debug without success. I can see delve running, my requests are stopping, but no breakpoint triggers happens from the nvim dap view. And no threads are being displayed on the Threads tab too.

This is my current config

-- require("nvim-dap-virtual-text").setup()
vim.fn.sign_define(
	"DapBreakpoint",
	{ text = "🔴", texthl = "DapBreakpoint", linehl = "DapBreakpoint", numhl = "DapBreakpoint" }
)

vim.fn.sign_define("DapStopped", {
	text = "▶️",
	texthl = "DiagnosticSignWarn",
	linehl = "Visual",
	numhl = "DiagnosticSignWarn",
})

-- Debugger
vim.api.nvim_set_keymap(
	"n",
	"<leader>dt",
	":DapViewToggle<CR>",
	{ noremap = true, silent = true, desc = "Debug toggle UI" }
)
vim.api.nvim_set_keymap(
	"n",
	"<leader>db",
	":DapToggleBreakpoint<CR>",
	{ noremap = true, silent = true, desc = "Debug toggle Breakpoint" }
)
vim.keymap.set("n", "<leader>dB", function()
	require("dap").set_breakpoint(vim.fn.input("Breakpoint condition: "))
end, { noremap = true, silent = true, desc = "Debug toggle Conditional Breakpoint" })
vim.api.nvim_set_keymap("n", "<leader>ds", ":DapContinue<CR>", { noremap = true, silent = true, desc = "Debut Start" })
vim.api.nvim_set_keymap(
	"n",
	"<leader>dc",
	":DapTerminate<CR>",
	{ noremap = true, silent = true, desc = "Debug Cancel/Close" }
)
vim.api.nvim_set_keymap(
	"n",
	"<leader>de",
	"<cmd>lua require('dap-view').eval()<cr>",
	{ noremap = true, silent = true, desc = "Eval" }
)
vim.api.nvim_set_keymap("n", "<leader>dr", ":DapViewOpen<CR>", { noremap = true, silent = true, desc = "Debug reset" })
vim.api.nvim_set_keymap(
	"n",
	"<F5>",
	"<cmd>lua require'dap'.step_back()<cr>",
	{ noremap = true, silent = true, desc = "Debug step back" }
)
vim.api.nvim_set_keymap(
	"n",
	"<F7>",
	"<cmd>lua require'dap'.step_into()<cr>",
	{ noremap = true, silent = true, desc = "Debug step into" }
)
vim.api.nvim_set_keymap(
	"n",
	"<F8>",
	"<cmd>lua require'dap'.step_over()<cr>",
	{ noremap = true, silent = true, desc = "Debug step over" }
)
vim.api.nvim_set_keymap(
	"n",
	"<F9>",
	"<cmd>lua require'dap'.run_to_cursor()<cr>",
	{ noremap = true, silent = true, desc = "Debug Run to cursor" }
)

-- local M = {}
-- M.config = function()
local dap = require("dap")
local dap_view = require("dap-view")

require("mason-nvim-dap").setup({
	-- Makes a best effort to setup the various debuggers with
	-- reasonable debug configurations
	automatic_installation = true, -- FIX: Looks like this is not installing automatically the adapters. Use :Mason DAP instead.

	-- You can provide additional configuration to the handlers,
	-- see mason-nvim-dap README for more information
	handlers = {},

	-- You'll need to check that you have the required things installed
	-- online, please don't ask me how to install them :)
	ensure_installed = {
		-- Update this to ensure that you have the debuggers for the langs you want
		"delve", -- GO and C
		"codelldb", -- Rust
		"javadbg", -- java-debug-adapter
		"javatest",
		"mock",
		"kotlin",
		"js",
		"chrome",
		"firefox",
		"python",
	},
})

-- Auto-open dap-view when debugging starts/stops (replaces dapui listeners)
dap.listeners.after.event_initialized["dap_view_config"] = function()
	dap_view.open()
end

dap.listeners.after.event_stopped["dap_view_config"] = function()
	dap_view.open()
end

dap.listeners.before.event_terminated["dap_view_config"] = function()
	dap_view.close()
end

dap.listeners.before.event_exited["dap_view_config"] = function()
	dap_view.close()
end

-- Check current debug status
vim.keymap.set("n", "<leader>dstatus", function()
	local session = require("dap").session()
	if session then
		if session.stopped_thread_id then
			print("STOPPED at breakpoint - ready for step commands")
			print("Use F7=step_into, F8=step_over, F9=run_to_cursor")
		else
			print("Running - not stopped")
		end
	else
		print("No debug session")
	end
end, { desc = "Check debug status" })

-- Install golang specific config
-- require("dap-go").setup({
-- 	delve = {
-- 		-- On Windows delve must be run attached or it crashes.
-- 		-- See https://github.com/leoluz/nvim-dap-go/blob/main/README.md#configuring
-- 		detached = vim.fn.has("win32") == 0,
-- 	},
-- })

dap.adapters.go = function(callback, config)
	if config.mode == "remote" and config.request == "attach" then
		callback({
			type = "server",
			host = config.host or "127.0.0.1",
			port = config.port or "38697",
		})
	else
		callback({
			type = "server",
			port = "${port}",
			executable = {
				command = "dlv",
				args = { "dap", "-l", "127.0.0.1:${port}", "--log", "--log-output=dap" },
				detached = vim.fn.has("win32") == 0,
			},
		})
	end
end

dap.configurations.go = {
	{
		type = "go",
		name = "Debug Fiber Main Directly",
		request = "launch",
		program = "./cmd/api/main.go",
		buildFlags = "-tags=fts5",
	},
	{
		type = "go",
		name = "Attach to running Delve (manual)",
		request = "attach",
		mode = "remote",
		host = "127.0.0.1",
		port = 2345,
	},
	{
		type = "go",
		name = "Attach",
		mode = "local",
		request = "attach",
		processId = require("dap.utils").pick_process,
	},
	{
		type = "go",
		name = "Debug Current File",
		request = "launch",
		program = "${file}",
		stopOnEntry = true,
	},
	{
		type = "go",
		name = "Debug (Arguments)",
		request = "launch",
		program = "${file}",
		args = function()
			local args_string = vim.fn.input("Arguments: ")
			return vim.split(args_string, " ", true)
		end,
	},
	{
		type = "go",
		name = "Debug (Arguments & Build Flags)",
		request = "launch",
		program = "${file}",
		buildFlags = function()
			return vim.fn.input("Build Flags: ")
		end,
		args = function()
			local args_string = vim.fn.input("Arguments: ")
			return vim.split(args_string, " ", true)
		end,
	},
	{
		type = "go",
		name = "Debug Package",
		request = "launch",
		program = "${fileDirname}",
	},
	{
		type = "go",
		name = "Debug test",
		request = "launch",
		mode = "test",
		program = "${file}",
	},
	{
		type = "go",
		name = "Debug test (go.mod)",
		request = "launch",
		mode = "test",
		program = "./${relativeFileDirname}",
	},

	-- Your custom fts5 debug configs
	{
		type = "go",
		name = "Debug Go App (fts5 enabled)",
		request = "launch",
		mode = "exec",
		program = "${file}",
		buildFlags = "-tags=fts5",
		args = {},
	},
	{
		type = "go",
		name = "Debug Go Test (fts5 enabled)",
		request = "launch",
		mode = "test",
		program = "${fileDirname}",
		buildFlags = "-tags=fts5",
		args = {},
	},
}

--Java debugger adapter settings
dap.configurations.java = {
	-- {
	-- 	name = "Debug (Attach) - Remote",
	-- 	type = "java",
	-- 	request = "attach",
	-- 	hostName = "127.0.0.1",
	-- 	port = 5005,
	-- },
	{
		name = "Debug Cureent File",
		type = "java",
		request = "launch",
		program = "${file}",
	},
}
-- end

local dap = require("dap")
dap.adapters.kotlin = {
	type = "executable",
	command = "kotlin-debug-adapter",
	options = { auto_continue_if_many_stopped = false },
}

dap.configurations.kotlin = {
	{
		type = "kotlin",
		request = "launch",
		name = "This file",
		-- may differ, when in doubt, whatever your project structure may be,
		-- it has to correspond to the class file located at `build/classes/`
		-- and of course you have to build before you debug

		mainClass = function()
			local root = vim.fs.find("src", { path = vim.uv.cwd(), upward = true, stop = vim.env.HOME })[1] or ""
			local fname = vim.api.nvim_buf_get_name(0)
			-- src/main/kotlin/websearch/Main.kt -> websearch.MainKt
			return fname:gsub(root, ""):gsub("main/kotlin/", ""):gsub(".kt", "Kt"):gsub("/", "."):sub(2, -1)
		end,

		projectRoot = "${workspaceFolder}",
		jsonLogFile = "",
		enableJsonLogging = false,
	},
	{
		-- Use this for unit tests
		-- First, run
		-- ./gradlew --info cleanTest test --debug-jvm
		-- then attach the debugger to it
		type = "kotlin",
		request = "attach",
		name = "Attach to debugging session",
		port = 5005,
		args = {},
		projectRoot = vim.fn.getcwd,
		hostName = "localhost",
		timeout = 2000,
	},
}

---- Add this to see debug output
require("dap").set_log_level("DEBUG")

Steps To Reproduce

Use the same config and try to debug a main.go file.

Expected Behavior

Get the breakpoints working.

[igorlfs]

Hello,

my requests are stopping, but no breakpoint triggers happens from the nvim dap view

What exactly do you mean by that?

And no threads are being displayed on the Threads tab too

Threads are first shown when a session stops. I assume that's not happening to you?

This is my current config

Can you please share a minimal config, with only the essential to reproduce the problem? Please include a single instance of:

• An adapter definition
• A debugging configuration

To be clear: keymaps, other plugins and other debugging configurations only add noise.

Steps To Reproduce

Use the same config and try to debug a main.go file.

Expected Behavior

Get the breakpoints working.

Please, share details. As much as you can. For instance: (1) open this sample main.go (with an actual example); (2) set a breakpoint on line 10; (3) :DapViewToggle; (4) :DapContinue; (5) X happens, but I expect Y to happen.

[igorlfs]

Also, by the way, it looks like you're not calling require"dap-view".setup(), which you absolutely should.

[igorlfs]

Hey, sorry if I was a little harsh earlier. Do you still need help with the setup?

[catgoose]

@igorlfs I have been unavailable for a while so sorry for abandoning that PR with the go/delve support.

This is how I'm configuring dap:

  dap.adapters.go = function(callback)
    require("dap-view").open()
    callback({
      type = "executable",
      command = vim.fn.expand("$MASON") .. "/packages/go-debug-adapter/go-debug-adapter",
      executable = {
        command =   vim.fn.exepath("dlv"),
        args = { "dap", "-l", "${host}:${port}", "--log", "--log-output=dap" },
      },
    })
  end

The Exceptions and Console tabs do not show anything of course, but I see everything else using delve. Exceptions are not supported by delve, and since delve has no integrated console, you can view the output in the REPL.

The only thing this is missing from my old, hacky solution (https://github.com/catgoose/nvim/blob/5c4eceb991f34c6bec68590339335bc278745810/lua/config/dap/go.lua#L27-L79) is you can't interact with binary from the REPL. This really isn't a problem unless you are making some CLI tool that requires input, but I guess at that point just use flags?

[igorlfs]

Hello,

is you can't interact with binary from the REPL

Indeed, that ought to require some hacks. However, have you seen the documentation for the "anchoring" setup? It was made specifically for the delve / go use case. Also, soon ™️, the custom_sections PR will land on main, which will allow you to create a "delve section".

If what you want can't be covered by either of these solutions, can you create a separate issue (or discussion)?

Please, do not add further comments here, as it's unrelated to OP's issue