gofmt
, the way it should be pronounced.
cd $(mktemp -d); go mod init tmp; go get mvdan.cc/gofumpt
Enforce a stricter format than gofmt
, while being backwards compatible. That
is, gofumpt
is happy with a subset of the formats that gofmt
is happy with.
The tool is a modified fork of gofmt
, so it can be used as a drop-in
replacement. Running gofmt
after gofumpt
should be a no-op.
A drop-in replacement for goimports
is also available:
cd $(mktemp -d); go mod init tmp; go get mvdan.cc/gofumpt/gofumports
No empty lines at the beginning or end of a function
example
func foo() {
println("bar")
}
func foo() {
println("bar")
}
No empty lines around a lone statement (or comment) in a block
example
if err != nil {
return err
}
if err != nil {
return err
}
No empty lines before a simple error check
example
foo, err := processFoo()
if err != nil {
return err
}
foo, err := processFoo()
if err != nil {
return err
}
Composite literals with elements in separate lines must also separate both braces
example
var ints = []int{1, 2,
3, 4}
var ints = []int{
1, 2,
3, 4,
}
std
imports must be in a separate group at the top
example
import (
"foo.com/bar"
"io"
"io/ioutil"
)
import (
"io"
"io/ioutil"
"foo.com/bar"
)
Short case clauses should take a single line
example
switch c {
case 'a', 'b',
'c', 'd':
}
switch c {
case 'a', 'b', 'c', 'd':
}
Multiline top-level declarations must be separated by empty lines
example
func foo() {
println("multiline foo")
}
func bar() {
println("multiline bar")
}
func foo() {
println("multiline foo")
}
func bar() {
println("multiline bar")
}
Single var declarations should not be grouped with parentheses
example
var (
foo = "bar"
)
var foo = "bar"
Contiguous top-level declarations should be grouped together
example
var nicer = "x"
var with = "y"
var alignment = "z"
var (
nicer = "x"
with = "y"
alignment = "z"
)
Simple var-declaration statements should use short assignments
example
var s = "somestring"
s := "somestring"
Comments which aren't Go directives should start with a whitespace
example
//go:noinline
//Foo is awesome.
func Foo() {}
//go:noinline
// Foo is awesome.
func Foo() {}
gofumpt
is a replacement for gofmt
, so you can simply go get
it as
described at the top of this README and use it.
Alternatively, to use the tool with VS Code, add these settings:
"go.formatTool": "goimports",
"go.alternateTools": {
"goimports": "gofumports",
},
"go.languageServerExperimentalFeatures": {
"format": false
}
You can use gofmt
instead of goimports
and gofumpt
instead of gofumports
if you don't need auto-importing on-save.
This tool is a place to experiment. In the long term, the features that work
well might be proposed for gofmt
itself.
The tool is also compatible with gofmt
and is aimed to be stable, so you can
rely on it for your code as long as you pin a version of it.
Note that much of the code is copied from Go's gofmt
and goimports
commands.
You can tell which files originate from the Go repository from their copyright
headers. Their license file is LICENSE.google
.
gofumpt
's original source files are also under the 3-clause BSD license, with
the separate file LICENSE
.