README
¶
gofumpt
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
Features
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
}
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,
}
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")
}
A single declaration spec must not be grouped with parentheses
example
import (
"single"
)
var (
foo = "bar"
)
import "single"
var foo = "bar"
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() {}
Installation
In order to use the tool with VS Code refer to this issue.
License
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.
Documentation
¶
Overview ¶
Gofmt formats Go programs. It uses tabs for indentation and blanks for alignment. Alignment assumes that an editor is using a fixed-width font.
Without an explicit path, it processes the standard input. Given a file, it operates on that file; given a directory, it operates on all .go files in that directory, recursively. (Files starting with a period are ignored.) By default, gofmt prints the reformatted sources to standard output.
Usage:
gofmt [flags] [path ...]
The flags are:
-d Do not print reformatted sources to standard output. If a file's formatting is different than gofmt's, print diffs to standard output. -e Print all (including spurious) errors. -l Do not print reformatted sources to standard output. If a file's formatting is different from gofmt's, print its name to standard output. -r rule Apply the rewrite rule to the source before reformatting. -s Try to simplify code (after applying the rewrite rule, if any). -w Do not print reformatted sources to standard output. If a file's formatting is different from gofmt's, overwrite it with gofmt's version. If an error occurred during overwriting, the original file is restored from an automatic backup.
Debugging support:
-cpuprofile filename Write cpu profile to the specified file.
The rewrite rule specified with the -r flag must be a string of the form:
pattern -> replacement
Both pattern and replacement must be valid Go expressions. In the pattern, single-character lowercase identifiers serve as wildcards matching arbitrary sub-expressions; those expressions will be substituted for the same identifiers in the replacement.
When gofmt reads from standard input, it accepts either a full Go program or a program fragment. A program fragment must be a syntactically valid declaration list, statement list, or expression. When formatting such a fragment, gofmt preserves leading indentation as well as leading and trailing spaces, so that individual sections of a Go program can be formatted by piping them through gofmt.
Examples ¶
To check files for unnecessary parentheses:
gofmt -r '(a) -> a' -l *.go
To remove the parentheses:
gofmt -r '(a) -> a' -w *.go
To convert the package tree from explicit slice upper bounds to implicit ones:
gofmt -r 'α[β:len(α)] -> α[β:]' -w $GOROOT/src
The simplify command ¶
When invoked with -s gofmt will make the following source transformations where possible.
An array, slice, or map composite literal of the form:
[]T{T{}, T{}}
will be simplified to:
[]T{{}, {}}
A slice expression of the form:
s[a:len(s)]
will be simplified to:
s[a:]
A range of the form:
for x, _ = range v {...}
will be simplified to:
for x = range v {...}
A range of the form:
for _ = range v {...}
will be simplified to:
for range v {...}
This may result in changes that are incompatible with earlier versions of Go.
Notes ¶
Bugs ¶
The implementation of -r is a bit slow.
If -w fails, the restored original file may not have some of the original file attributes.
Source Files
Directories