Go layer

• Run gofmt / goimports on file save (see Autoformat)
• Auto-completion
• Source analysis using go-guru (see Guru)
• Refactoring with godoctor
• Edit struct field tags with gomodifytags
• Syntax checking with flycheck's built-in checkers or golangci-lint (see Linting)
• Test generation via go-gen-test (see Tests)
• Coverage profile visualization (see Coverage)
• List packages faster with gopkgs
• Fill a structure with default values using the fillstruct
• Gopls backend support (see LSP backend)
• Interactive debugger with LSP using dap-mode

To use this configuration layer, add it to your ~/.spacemacs. You will need to add go to the existing dotspacemacs-configuration-layers list in this file.

Basically you have to choose between multiple language backends. This choice defines mainly which kind of IDE features spacemacs can deliver.

Alternatively if non is set the lsp backend will be automatically chosen if the layer lsp is used otherwise go-mode will be used.

For best results, make sure that the auto-completion and syntax-checking layers are enabled as well.

This section lists dependencies which are independent of the language backend, most are installed directly via go get:

GO111MODULE=on CGO_ENABLED=0 go install -v -trimpath -ldflags '-s -w' github.com/golangci/golangci-lint/cmd/golangci-lint@latest
go install golang.org/x/tools/cmd/godoc@latest
go install golang.org/x/tools/cmd/goimports@latest
go install golang.org/x/tools/cmd/gorename@latest
go install golang.org/x/tools/cmd/guru@latest
go install github.com/cweill/gotests/...@latest
go install github.com/davidrjenni/reftools/cmd/fillstruct@latest
go install github.com/fatih/gomodifytags@latest
go install github.com/godoctor/godoctor@latest
go install github.com/haya14busa/gopkgs/cmd/gopkgs@latest
go install github.com/josharian/impl@latest
go install github.com/rogpeppe/godef@latest

By default, the go run command is go run. If you want to use a different command or run with environment variables, set the layer variable go-run-command.

(go :variables go-run-command "ENV_VAR=foo go run")

To run the current main package with command line arguments, set the value of go-run-args as a file local variable, e.g.

// Local Variables:
// go-run-args: "--output run.log"
// End:

By default, the tab width in Go mode is 8 spaces. To use a different value, set the layer variable go-tab-width, e.g.

(go :variables go-tab-width 4)

If you're using .editorconfig in your project, set the value to nil to avoid conflicts, i.e.

(go :variables go-tab-width nil)

To run gofmt before save, set the value to a non-nil, i.e.

(go :variables go-format-before-save t)

To use a different formatter, set the value of gofmt-command, e.g.

(go :variables gofmt-command "goimports")

If you wish to use golangci-lint, set the following layer variable to non-nil:

(go :variables go-use-golangci-lint t)

Check golangci-lint and flycheck-golangci-lint for more details.

Please remember that without properly configured flycheck-golangci-lint variables golangci-lint may not run as expected. The recommended way is to use a .golangi.yml in your project. But if this is not possible you can also set global command line flags for golangci-lint. Especially important is the selection of which linters to run and whether to lint test files too.

It may happen from time to time that golangci-lint is not able to parse a buffers content properly. This normally happens when there are basic errors in the file which prevent more complex analytics to run. In this case a set of errors will be shown at the top of the current buffer which are not properly parsed by flycheck. Spacemacs still shows basic errors in your buffer. When these have been fixed golangci-lint will regenerate and further diagnostic data will be made available.

When this happens please report a bug to `golangci-lint` they are working hard to fix these.

If you're using gocheck or testify in your project you can use the go-use-gocheck-for-testing or go-use-testify-for-testing variable to enable suite testing and to get single function testing to work.

Tests are run in a compilation buffer displayed in a popup window that can be closed by pressing C-g from any other window. The variable go-test-buffer-name can be customized to set the output buffer name.

By default, the go test command is go test. If you want to use a different command or test with environment variables, set the layer variable go-test-command.

(go :variables go-test-command "ENV_VAR=foo go test")

To provide additional arguments to go test, specify go-use-test-args.

(go :variables go-use-test-args "-race -timeout 10s")

go-coverage-display-buffer-func controls how go-coverage should display the coverage buffer. See display-buffer for a list of possible functions. The default value is display-buffer-reuse-window.

If you would like to use the Go Guru bindings in your work, in your project you will need to set the scope with SPC m f o. The scope is a comma separated set of packages, and Go's recursive operator is supported. In addition, you can prefix it with - to exclude a package from searching.

Currently there are two implementations to integrate with the dap debugger in golang, dap-go (which depends on a vscode extension) which is depreciated and dap-dlv-go the default choice which is self-contained. More details about both can be found here.

By default dap-dlv-go is used, however it is also possible to use the legacy integration dap-go, to do so set the layer variable go-dap-mode as shown below:

(go :variables go-dap-mode 'dap-go)