When to use leading underscore in variable names in Go

Is there any special purpose of leading _ in a variable's name?

Example:
func (_m *MockTracker)...

from here.

There is no special meaning defined for a leading underscore in an identifier name in the spec:

> Identifiers
>
> Identifiers name program entities such as variables and types. An
> identifier is a sequence of one or more letters and digits. The first
> character in an identifier must be a letter.
>
> identifier = letter { letter | unicode_digit } .
>
> a
> _x9
> ThisVariableIsExported
> αβ

Your sample is generated code from mockgen.go.

In the package you linked you'll see things like:

// Recorder for MockTracker (not exported)
type _MockTrackerRecorder struct {
    mock *MockTracker
}

The sanitize function in the mockgen package prepends an underscore to package names and it seems that it's otherwise used for consistency and to ensure that identifier names remain private (i.e. not exported because they start with a capital letter). But it's not something that is defined in the Go spec.

// sanitize cleans up a string to make a suitable package name.
func sanitize(s string) string {
	t := ""
	for _, r := range s {
		if t == "" {
			if unicode.IsLetter(r) || r == '_' {
				t += string(r)
				continue
			}
		} else {
			if unicode.IsLetter(r) || unicode.IsDigit(r) || r == '_' {
				t += string(r)
				continue
			}
		}
		t += "_"
	}
	if t == "_" {
		t = "x"
	}
	return t
}

It seems that there is nothing regarding the _ in a variable name in the naming convetions.
From here: effective go

Another use case is for unexported global variables. It's a convention that many Go developers follow and explained in this section of the Uber style guide.