Gopls

https://go.dev/gopls
Admin
Gopls is the official language server for Go that provides IDE features like navigation, completion,...
Tokens:110,530
Snippets:967
Trust Score:10
Update:1 day ago
Show doc for...
Tokens:
Raw
### Run gopls tests from the root directory

Source: https://go.dev/gopls/contributing

Example command to run tests for gopls packages when working outside the gopls directory, using the workspace setup.

```bash
tools$ go test -short ./gopls/...
```

--------------------------------

### symbolStyle setting example

Source: https://go.dev/gopls/settings

Example JSON5 configuration showing the symbolStyle setting set to "Dynamic" within the gopls settings object.

```json5
"gopls": {
...
  "symbolStyle": "Dynamic",
...
}
```

--------------------------------

### SA1005: Shell command example

Source: https://go.dev/gopls/analyzers

Example of a shell command that the analyzer contrasts with the exec.Command equivalent.

```text
ls / /tmp
```

--------------------------------

### Install gopls with go install

Source: https://go.dev/gopls/

Run this command to install the latest stable release of gopls. Some editors, such as VS Code, handle this step automatically. After updating, you may need to restart running Gopls processes; on UNIX, use 'killall gopls'.

```sh
go install golang.org/x/tools/gopls@latest
```

--------------------------------

### Basic gopls setup with nvim-lspconfig

Source: https://go.dev/gopls/editor/vim

Minimal configuration to set up gopls using nvim-lspconfig's defaults.

```lua
local lspconfig = require("lspconfig")
lspconfig.gopls.setup({})
```

--------------------------------

### nilness: panic with nil value example

Source: https://go.dev/gopls/analyzers

Example of a panic with a nil value reported by nilness.

```go
if p == nil {
    panic(p)
}

```

--------------------------------

### stringsbuilder: after example with WriteString

Source: https://go.dev/gopls/analyzers

The suggested fix for the fmt.Sprintf example. The WriteString call can be further simplified to fmt.Fprintf(&s, "%v", x) but stringsbuilder does not perform this simplification; it requires staticcheck analyzer QF1012.

```go
var s strings.Builder
for x := range seq {
    s.WriteString(fmt.Sprintf("%v", x))
}
```

--------------------------------

### Build gopls with local changes

Source: https://go.dev/gopls/contributing

Run these commands from the gopls directory to install a version of gopls with your changes applied.

```bash
cd /path/to/tools/gopls
go install
```

--------------------------------

### Install and run fieldalignment command

Source: https://go.dev/gopls/analyzers

Commands to install and run the fieldalignment analyzer standalone. Default: off; enable by setting "analyses": {"fieldalignment": true}.

```shell
$ go install golang.org/x/tools/go/analysis/passes/fieldalignment/cmd/fieldalignment@latest
$ fieldalignment [packages]
```

--------------------------------

### S1017: Replace manual trimming with strings.TrimPrefix - Before

Source: https://go.dev/gopls/analyzers

Before example for S1017: using strings.HasPrefix and manual slicing to trim a prefix.

```go
if strings.HasPrefix(str, prefix) {
    str = str[len(prefix):]
}
```

--------------------------------

### Unused parameter diagnostic example

Source: https://go.dev/gopls/features/transformation

Example showing the `unusedparams` analyzer diagnostic for an unused parameter `x`. The analyzer does not report diagnostics for address-taken or exported functions.

```go
func f(x, y int) { // "unused parameter: x"
    fmt.Println(y)
}
```

--------------------------------

### stringsbuilder: before example of string concatenation

Source: https://go.dev/gopls/analyzers

Example of repeated string += concatenation that the stringsbuilder analyzer replaces with strings.Builder to avoid quadratic memory allocation and improve performance.

```go
var s = "["
for x := range seq {
    s += x
    s += "."
}
s += "]"
use(s)
```

--------------------------------

### nilness: complex control flow example

Source: https://go.dev/gopls/analyzers

Example showing a complex control flow where err.Error is guaranteed to panic because err is nil after the first return. The intervening loop is a distraction.

```go
...
err := g.Wait()
if err != nil {
    return err
}
partialSuccess := false
for _, err := range errs {
    if err == nil {
        partialSuccess = true
        break
    }
}
if partialSuccess {
    reportStatus(StatusMessage{
        Code:   code.ERROR,
        Detail: err.Error(), // "nil dereference in dynamic method call"
    })
    return nil
}

```

--------------------------------

### Start gopls daemon on Unix domain socket

Source: https://go.dev/gopls/daemon

Manually start a gopls daemon listening on a Unix domain socket. Prefix the address with 'unix;' and enclose the value in quotes because ';' is a special shell character. This syntax is subject to change.

```bash
gopls -listen="unix;/tmp/gopls-daemon-socket" -logfile=auto -debug=:0
```

--------------------------------

### S1032: Before - sort.Sort with sort.StringSlice

Source: https://go.dev/gopls/analyzers

Example of verbose sort call that S1032 suggests simplifying.

```go
sort.Sort(sort.StringSlice(x))
```

--------------------------------

### embedlit: struct definitions for redundant embedded field example

Source: https://go.dev/gopls/analyzers

Defines structs T and U where T embeds U. This is the setup for the embedlit analyzer example showing how to simplify composite literals.

```go
type T struct {
    U
}

type U struct {
    x int
}
```

--------------------------------

### Initialize a go.work workspace with go work init and go work use

Source: https://go.dev/gopls/workspace

Creates a go.work file in the current directory and adds the tools/gopls and mod modules to it. Run from the $WORK directory to enable simultaneous development on both modules.

```sh
cd $WORK
go work init
go work use tools/gopls mod
```

--------------------------------

### testinggoroutine: Fatal called from non-test goroutine

Source: https://go.dev/gopls/analyzers

The testinggoroutine analyzer detects calls to functions like Fatal, Fatalf, FailNow, and Skip methods from goroutines started by a test. The example shows a call to t.Fatal inside a goroutine, which triggers an error.

```go
func TestFoo(t *testing.T) {
    go func() {
        t.Fatal("oops") // error: (*T).Fatal called from non-test goroutine
    }()
}
```

--------------------------------

### parameterNames inlay hint example

Source: https://go.dev/gopls/inlayHints

Shows inlay hints for parameter names. Disabled by default; enable with "hints": {"parameterNames": true}.

```go
    parseInt(« str: » "123", « radix: » 8)
```

--------------------------------

### SA1005: exec.Command equivalent

Source: https://go.dev/gopls/analyzers

Shows the correct way to run the shell command 'ls / /tmp' using exec.Command.

```go
exec.Command("ls", "/", "/tmp")
```

--------------------------------

### Install latest gopls version

Source: https://go.dev/gopls/features/mcp

Installs gopls v0.20 or higher, required for MCP support, using the go install command.

```bash
$ go install golang.org/x/tools/gopls@latest
```

--------------------------------

### Configure gopls with unusedparams, staticcheck, and gofumpt

Source: https://go.dev/gopls/editor/vim

Example configuration enabling the unusedparams analysis, staticcheck, and gofumpt for gopls.

```lua
local lspconfig = require("lspconfig")
lspconfig.gopls.setup({
  settings = {
    gopls = {
      analyses = {
        unusedparams = true,
      },
      staticcheck = true,
      gofumpt = true,
    },
  },
})
```

--------------------------------

### Print gopls MCP model instructions to a file

Source: https://go.dev/gopls/features/mcp

Loads model instructions as additional context in an AI-assisted session by redirecting output to a file.

```bash
gopls mcp -instructions > /path/to/contextFile.md
```

--------------------------------

### nilness: impossible condition example

Source: https://go.dev/gopls/analyzers

Example of an impossible condition reported by nilness: comparing a function to nil.

```go
if f == nil { // impossible condition (f is a function)
}

```

--------------------------------

### LanguageClient-neovim gopls configuration

Source: https://go.dev/gopls/editor/vim

Launch gopls for Go files and run gofmt on save using LanguageClient-neovim.

```vim
" Launch gopls when Go files are in use
let g:LanguageClient_serverCommands = {
       \ 'go': ['gopls']
       \ }
" Run gofmt on save
autocmd BufWritePre *.go :call LanguageClient#textDocument_formatting_sync()
```

--------------------------------

### nilness: nil dereference example

Source: https://go.dev/gopls/analyzers

Example of a nil dereference reported by nilness: dereferencing a pointer that is known to be nil.

```go
if p == nil {
    print(*p) // nil dereference
}

```

--------------------------------

### Global LSP settings with custom PATH and LSP options

Source: https://go.dev/gopls/editor/sublime

Supplies a specific PATH for finding gopls and go, and sets LSP options like show_references_in_quick_panel, log_debug, inhibit_snippet_completions, and inhibit_word_completions. Includes comments noting deprecated settings.

```json
{
    "clients": {
        "gopls": {
            "enabled": true,
            "env": {
                "PATH": "/path/to/your/go/bin",
            }
        }
    },
    // Recommended by https://agniva.me/gopls/2021/01/02/setting-up-gopls-sublime.html
    // except log_stderr mentioned there is no longer recognized.
    "show_references_in_quick_panel": true,
    "log_debug": true,
    // These two are recommended by LSP-json as replacement for deprecated only_show_lsp_completions
    "inhibit_snippet_completions": true,
    "inhibit_word_completions": true,
 }
```

--------------------------------

### nilness: tautological condition example

Source: https://go.dev/gopls/analyzers

Example of a tautological condition reported by nilness: comparing a pointer that is always non-nil.

```go
p := &v
...
if p != nil { // tautological condition
}

```

--------------------------------

### Enable inlay hints with parameterNames

Source: https://go.dev/gopls/features/passive

Set the 'hints' setting in your editor configuration to enable inlay hints. The default is empty, so you must add at least one hint kind. This example enables parameterNames.

```json5
"hints": {"parameterNames": true}
```

--------------------------------

### stringsbuilder: before example with fmt.Sprintf addend

Source: https://go.dev/gopls/analyzers

Example where the addend is a call to fmt.Sprintf. The analyzer replaces the concatenation with WriteString, but does not simplify to fmt.Fprintf.

```go
var s string
for x := range seq {
    s += fmt.Sprintf("%v", x)
}
```

--------------------------------

### Create a go.work file in the root directory

Source: https://go.dev/gopls/contributing

Recommended go.work file to allow specifying gopls packages when working outside the gopls directory. Place this in the root directory.

```go
go 1.25

use .
use ./gopls
```

--------------------------------

### Install a specific gopls version

Source: https://go.dev/gopls/advanced

Use this command to install a specific version of gopls, such as a prerelease. Replace vX.Y.Z with the desired version.

```sh
$ go install golang.org/x/tools/gopls@vX.Y.Z
```

--------------------------------

### recursiveiter: Example use of every operator

Source: https://go.dev/gopls/analyzers

Example usage of the every operator that prints whether every element in the tree is an even number.

```go
even := func(x int) bool { return x&1 == 0 }
println(t.every(even))
```

--------------------------------

### SA9004: Output of method set example

Source: https://go.dev/gopls/analyzers

The output of the previous example, showing that EnumSecond prints as 2 instead of using the String method.

```text
an enum
2
```

--------------------------------

### Run gopls codelens command

Source: https://go.dev/gopls/codelenses

Example of using the CLI command 'gopls codelens' to run a test at a specified line. The command is 'gopls codelens -exec file.go:123 "run test"'.

```shell
gopls codelens -exec file.go:123 "run test"
```

--------------------------------

### SA9004: Compile error example

Source: https://go.dev/gopls/analyzers

Example code that fails to compile because EnumSecond defaults to int while EnumFirst is uint8, causing a type mismatch in assignment.

```go
package pkg

const (
    EnumFirst  uint8 = 1
    EnumSecond       = 2
)

func fn(useFirst bool) {
    x := EnumSecond
    if useFirst {
        x = EnumFirst
    }
}
```

--------------------------------

### SA1005: Running a command in a shell

Source: https://go.dev/gopls/analyzers

Example of using exec.Command with /bin/sh to run a shell command. Note that not all systems, particularly Windows, have /bin/sh.

```go
exec.Command("/bin/sh", "-c", "ls | grep Awesome")
```

--------------------------------

### constantValues inlay hint example

Source: https://go.dev/gopls/inlayHints

Shows inlay hints for constant values. Disabled by default; enable with "hints": {"constantValues": true}.

```go
    const (
        KindNone   Kind = iota« = 0»
        KindPrint«  = 1»
        KindPrintf« = 2»
        KindErrorf« = 3»
    )
```

--------------------------------

### SA9004: Losing method sets example

Source: https://go.dev/gopls/analyzers

Example showing that a constant without explicit type loses the method set of the type, causing different output.

```go
package main

import "fmt"

type Enum int

func (e Enum) String() string {
    return "an enum"
}

const (
    EnumFirst  Enum = 1
    EnumSecond      = 2
)

func main() {
    fmt.Println(EnumFirst)
    fmt.Println(EnumSecond)
}
```

--------------------------------

### Create a go.work file for working on std and cmd

Source: https://go.dev/gopls/advanced

Run these commands inside GOROOT/src to create a go.work file that includes the standard library and cmd directories. You must work inside GOROOT/src because the go command does not recognize go.work files in a parent directory.

```sh
cd $(go env GOROOT)/src
go work init . cmd
```

--------------------------------

### slog: missing final value example

Source: https://go.dev/gopls/analyzers

The slog checker reports calls where a final key is missing its value. This example shows a reported call with the diagnostic message.

```go
slog.Info("message", "k1", v1, "k2") // call to slog.Info missing a final value
```

--------------------------------

### Configure experimental gopls settings via lsp-register-custom-settings

Source: https://go.dev/gopls/editor/emacs

Use this to set experimental gopls settings in LSP Mode. The example enables completeUnimported and staticcheck. After changing settings, restart gopls with M-x lsp-restart-workspace.

```elisp
(lsp-register-custom-settings
 '(("gopls.completeUnimported" t t)
   ("gopls.staticcheck" t t)))
```
Tokens:
Raw