158 lines
6.0 KiB
Plaintext
158 lines
6.0 KiB
Plaintext
cp foo.go foo.go.orig
|
|
|
|
exec gofumpt -w foo.go
|
|
cmp foo.go foo.go.orig
|
|
|
|
env GOFUMPT_SPLIT_LONG_LINES=on
|
|
exec gofumpt -w foo.go
|
|
cmp foo.go foo.go.golden
|
|
|
|
exec gofumpt -d foo.go.golden
|
|
! stdout .
|
|
|
|
-- foo.go --
|
|
package p
|
|
|
|
func _() {
|
|
if err := f(argument1, argument2, argument3, argument4, argument5, argument6, argument7, argument8, argument9, argument10); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
// Tiny arguments to ensure the length calculation is right.
|
|
if err := f(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
// These wouldn't take significantly less horizontal space if split.
|
|
f(x, "one single very very very very very very very very very very very very very very very very long literal")
|
|
if err := f(x, "one single very very very very very very very very very very very very very very very very long literal"); err != nil {
|
|
panic(err)
|
|
}
|
|
{
|
|
{
|
|
{
|
|
{
|
|
println("first", "one single very very very very very very very very very very very very very long literal")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Allow splitting at the start of sub-lists too.
|
|
if err := f(argument1, argument2, argument3, argument4, someComplex{argument5, argument6, argument7, argument8, argument9, argument10}); err != nil {
|
|
panic(err)
|
|
}
|
|
if err := f(argument1, argument2, argument3, argument4, &someComplex{argument5, argument6, argument7, argument8, argument9, argument10}); err != nil {
|
|
panic(err)
|
|
}
|
|
if err := f(argument1, argument2, argument3, argument4, []someSlice{argument5, argument6, argument7, argument8, argument9, argument10}); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
// Allow splitting "lists" of binary expressions.
|
|
if boolean1 && boolean2 && boolean3 && boolean4 && boolean5 && boolean6 && boolean7 && boolean8 && boolean9 && boolean10 && boolean11 {
|
|
}
|
|
// Over 100, and we split in a way that doesn't break "len(" off.
|
|
if boolean1 || boolean2 || boolean3 || boolean4 || len(someVeryLongVarName.SomeVeryLongSelector) > 0 {
|
|
}
|
|
}
|
|
|
|
// Note that function declarations have a higher limit of 120.
|
|
|
|
// This line goes beyond the limit of 120, but splitting it would leave the
|
|
// following line with just 20 non-indentation characters. Not worth it.
|
|
func LongButNotWorthSplitting(argument1, argument2, argument3, argument4, argument5, argument6, argument7, argument8, argument9 int) bool {
|
|
}
|
|
|
|
// This line goes well past the limit and it should be split.
|
|
// Note that it has a nested func type in a parameter.
|
|
func TooLongWithFuncParam(fn func(int) (int, error), argument1, argument2, argument3, argument4, argument5, argument6, argument7, argument8, argument9, argument10 int) bool {
|
|
}
|
|
|
|
// This is like LongButNotWorthSplitting, but with a func parameter.
|
|
func LongButNotWorthSplitting2(fn func(int) (int, error), argument3, argument4, argument5, argument6, argument7, argument8, argument9 int) bool {
|
|
}
|
|
|
|
// Never split result parameter lists, as that could easily add confusion with
|
|
// extra input parameters.
|
|
func NeverSplitResults(argument1, argument2, argument3, argument4, argument5 int) (result1 int, result2, result3, result4, result5, result6, result7, result8 bool) {
|
|
}
|
|
-- foo.go.golden --
|
|
package p
|
|
|
|
func _() {
|
|
if err := f(argument1, argument2, argument3, argument4, argument5, argument6, argument7,
|
|
argument8, argument9, argument10); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
// Tiny arguments to ensure the length calculation is right.
|
|
if err := f(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, 0,
|
|
1, 2, 3, 4, 5, 6, 7, 8, 9, 10); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
// These wouldn't take significantly less horizontal space if split.
|
|
f(x, "one single very very very very very very very very very very very very very very very very long literal")
|
|
if err := f(x, "one single very very very very very very very very very very very very very very very very long literal"); err != nil {
|
|
panic(err)
|
|
}
|
|
{
|
|
{
|
|
{
|
|
{
|
|
println("first", "one single very very very very very very very very very very very very very long literal")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Allow splitting at the start of sub-lists too.
|
|
if err := f(argument1, argument2, argument3, argument4, someComplex{
|
|
argument5, argument6, argument7, argument8, argument9, argument10,
|
|
}); err != nil {
|
|
panic(err)
|
|
}
|
|
if err := f(argument1, argument2, argument3, argument4, &someComplex{
|
|
argument5, argument6, argument7, argument8, argument9, argument10,
|
|
}); err != nil {
|
|
panic(err)
|
|
}
|
|
if err := f(argument1, argument2, argument3, argument4, []someSlice{
|
|
argument5, argument6, argument7, argument8, argument9, argument10,
|
|
}); err != nil {
|
|
panic(err)
|
|
}
|
|
|
|
// Allow splitting "lists" of binary expressions.
|
|
if boolean1 && boolean2 && boolean3 && boolean4 && boolean5 && boolean6 && boolean7 &&
|
|
boolean8 && boolean9 && boolean10 && boolean11 {
|
|
}
|
|
// Over 100, and we split in a way that doesn't break "len(" off.
|
|
if boolean1 || boolean2 || boolean3 || boolean4 ||
|
|
len(someVeryLongVarName.SomeVeryLongSelector) > 0 {
|
|
}
|
|
}
|
|
|
|
// Note that function declarations have a higher limit of 120.
|
|
|
|
// This line goes beyond the limit of 120, but splitting it would leave the
|
|
// following line with just 20 non-indentation characters. Not worth it.
|
|
func LongButNotWorthSplitting(argument1, argument2, argument3, argument4, argument5, argument6, argument7, argument8, argument9 int) bool {
|
|
}
|
|
|
|
// This line goes well past the limit and it should be split.
|
|
// Note that it has a nested func type in a parameter.
|
|
func TooLongWithFuncParam(fn func(int) (int, error), argument1, argument2, argument3, argument4,
|
|
argument5, argument6, argument7, argument8, argument9, argument10 int) bool {
|
|
}
|
|
|
|
// This is like LongButNotWorthSplitting, but with a func parameter.
|
|
func LongButNotWorthSplitting2(fn func(int) (int, error), argument3, argument4, argument5, argument6, argument7, argument8, argument9 int) bool {
|
|
}
|
|
|
|
// Never split result parameter lists, as that could easily add confusion with
|
|
// extra input parameters.
|
|
func NeverSplitResults(argument1, argument2, argument3, argument4, argument5 int) (result1 int, result2, result3, result4, result5, result6, result7, result8 bool) {
|
|
}
|