formatterの悩み

この記事は、[クラスター Advent Calendar 2022（2ページ目）](https://qiita.com/advent-calendar/2022/cluster)の14日目の記事です。
昨日は、@pocketberserker さんの、[会社に雑LTという文化があったので開催してみた](https://pocketberserker.hatenablog.com/entry/2022/12/13/232505)でした。

こんにちは、あるいはこんばんは。
Go歴3ヶ月の@homulerです。
クラスターではサーバーサイドエンジニアをやっています。

今回は、日々の開発でお世話になっている、Goのコードのformatterについての話をします。

### Gofmtとgoimports
Goは、公式が[Gofmt](https://pkg.go.dev/cmd/gofmt)というツールを提供していて、Gofmtを使っているかは別として、ほとんどのプロジェクトにおいて、コードはなんらかのツールを使って自動整形されていると思います。
空気のように存在していて、Go初心者が真っ先にお世話になるツール。

https://go.dev/blog/gofmt

他の言語でもこういったツールは存在しますが、Gofmtは、フォーマットに関して設定が（ほぼ）できないようになっていて、どのルールを採用するかという争いが発生しないのが特徴的です。

Goは、Gofmtの他に、（リポジトリは別ですが）[goimports](https://pkg.go.dev/golang.org/x/tools/cmd/goimports)というツールを提供していて、こちらは[import declarations](https://go.dev/ref/spec#Import_declarations)の修正が主な用途だと思われますが、Gofmtと同様の整形も行ってくれます[^1]。

コードのフォーマットという点において、goimportsは少し面白い機能を持っていて、
1. 複数のimport declarationを1つにマージする[^2]
   ```go
   import "errors"
   import "fmt"
   ```
   ↓
   ```go
   import (
       "errors"
       "fmt"
   )
   ```
1. import specをグルーピング[^3]し、グループ内でアルファベット順に並べる
   ```go
   import (
      "github.com/homuler/foo"
      "golang.org/x/example/stringutil"
      "local.package.com/bar"
      "fmt"
      "errors"
   )
   ```
   ↓
   ```go
   import (
       "errors"
       "fmt"

       "github.com/homuler/foo"
       "golang.org/x/example/stringutil"

       "local.package.com/bar"
   )
   ```

ことができます[^4]。

これを初めて聞いた時は、素直にすごいなと思ったわけです。
Gofmtは、実際はどうあれ、ASTを好きな形の文字列として出力してるんだろうな、と想像がつくので、それほど中身に興味を持たなかったのですが、goimportsのように、並べ替えやマージを行っているとなると、話は変わってきます。

間にコメントがあった場合、どうしているんでしょうか？

[^1]: Gofmtのすべての機能にアクセスできるわけではありません（例えば、 `-s` を指定してASTを簡略化することはできません）
[^2]: `import "C"`が絡むと例外的に無視されますが
[^3]: グルーピングの内容は[後で](#%E3%82%B0%E3%83%AB%E3%83%BC%E3%83%94%E3%83%B3%E3%82%B0)
[^4]: GofmtもImportSpecを並び替える機能を持っています

## goimportsの挙動
どう整形するかというのは、結局は決めの問題です。
以下では、goimportsの実際の動きを見ていきます。

### グルーピング
まずは、グルーピングから。
goimportsは、packageを
1. 標準ライブラリ
1. appengineのパッケージ
1. 外部のパッケージ
1. ローカルのパッケージ

の4つに分けて、それぞれの中でパッケージ名による並べ替えを行い、グループの間には空行を挿入します。
また、パッケージ名の間に空行がある場合、これらも別のグループとして扱います。

```go
import (
    "fmt"
    "github.com/homuler/foo"

    "errors"
    "context"
)
```
↓
```go
import (
    "fmt"

    "github.com/homuler/foo"

    "context"
    "errors"
)
```

空行を無視する判断もありそうですが、開発者が意図的に空行を挿入した可能性もあり、それを尊重したものと思われます。
では、コメントが含まれていた場合はどうでしょうか？

```go
import (
	"fmt"
	"github.com/homuler/foo"
	// doc comment for errors
	"errors"
	"context"
)
```
↓
```go
import (
	"fmt"

	"github.com/homuler/foo"

	// doc comment for errors
	"context"
	"errors"
)
```

コメントを無視してそうに見えますが、これだけだとなんとも言えないので、次に行ってみます。

### 並べ替え
まずはline comment付きの場合。

```go
import (
	"fmt" // fmt
	"github.com/homuler/foo" // foo
	"errors" // errors
)
```
↓
```go
import (
	"errors" // errors
	"fmt"    // fmt

	"github.com/homuler/foo" // foo
)
```

なにやらいい感じがします。
間にコメントがある場合も試してみます。

```go
import (
	"fmt" // fmt
	// foo
	"github.com/homuler/foo"
	"errors" // errors
)
```
↓
```go
import (
	"fmt" // fmt
	// foo
	"errors" // errors

	"github.com/homuler/foo"
)
```

まぁ、そういうこともある。
別に開発者の意思を尊重してるわけではない気もしてきましたが、もう一つ見てみます。

### マージ
マージにはいろいろなパターンがありますが、一例。

```go
import (
	"fmt" // fmt
	"github.com/homuler/foo" // foo
)

import (
	"context" // context
	"errors" // errors
)
```
↓
```go
import (
	"context"
	"errors"
	"fmt"

	"github.com/homuler/foo" // fmt
	// foo
)

// context
// errors
```

潔い！
いや、一周回ってやっぱりすごい気がしてきました。

そもそも、`import "C"`を除いて、複数のimport文が書かれるケースは少ないわけですし、マージ処理が必要な状況はめったに発生しないと考えられます。
その場合に、コメントはそのままにして、後でユーザーにコメントを移動させるという判断はもっともです（が、私は怖くてできなさそうな判断でもある）。


<br/>
<br/>
<br/>
<br/>
<br/>
<br/>
……いや、コメント無視したらアカンやろ。

## どうしてこうなった
この挙動を説明するための準備として、 [go/ast](https://pkg.go.dev/go/ast), [go/token](https://pkg.go.dev/go/token), [go/printer](https://pkg.go.dev/go/printer) の中身に触れておきます。

### go/ast
goimportsは、[`printer.Config.Fprint`](https://pkg.go.dev/go/printer#Config.Fprint)を使って[コードを整形します](https://cs.opensource.google/go/x/tools/+/master:internal/imports/imports.go;l=140)が[^5]、その引数として、ソースコードに対応する[ast.File](https://pkg.go.dev/go/ast#File)を渡しています。

以降の説明で必要になるのは、以下の3点です。
1. ASTの本体は、[ast.Decl](https://pkg.go.dev/go/ast#Decl)のsliceとして表現される (`Decls`)
1. すべてのコメントは、 `Decls` とは別に保持される（`Comments`）
1. 一部の[Node](https://pkg.go.dev/go/ast#Node)（e.g. [GenDecl](https://pkg.go.dev/go/ast#GenDecl), [ImportSpec](https://pkg.go.dev/go/ast#ImportSpec)）は、自身に紐付いたコメントへの参照（i.e. `Doc`, `Comment`）を持つ

### go/token
go/tokenも[File](https://pkg.go.dev/go/token#File)と呼ばれる構造体を持ち、これも`Config.Fprint`に引数として間接的に渡されます（直接的には、[token.FileSet](https://pkg.go.dev/go/token#FileSet)）。
exported fieldsを持たないのですが、内部にソースファイルの[改行位置の情報を保持しています](https://cs.opensource.google/go/go/+/refs/tags/go1.19.4:src/go/token/position.go;l=102)。

token.Fileが重要なのは、ast.Fileだけでは出力結果が一意に決まらないからです。

### go/printer
`Config.Fprint`は、ASTをpretty printします。
ast.Fileを引数に渡した場合、結局[`Decls`をprintする](https://cs.opensource.google/go/go/+/refs/tags/go1.19.4:src/go/printer/nodes.go;l=1999;drc=80f7484af76773b7591d57f8f5e4479603089b90)ことになります。

では、コメントはどうしているかというと、[printerが内部に`Comments` を保持していて](https://cs.opensource.google/go/go/+/refs/tags/go1.19.4:src/go/printer/printer.go;l=1129;drc=80f7484af76773b7591d57f8f5e4479603089b90)

1. tokenを出力
1. 次のtokenへ
1. 未出力のコメントがあったら、[コメントを出力](https://cs.opensource.google/go/go/+/refs/tags/go1.19.4:src/go/printer/printer.go;l=996;drc=80f7484af76773b7591d57f8f5e4479603089b90)（`flush`）
1. 次のtokenを出力
1. ...

という流れを繰り返して出力されます。つまり、`Decls`のカーソルと`Comments`のカーソルを交互に動かしながら出力しているようなイメージです（printer内部では、 [`intersperseComments`](https://cs.opensource.google/go/go/+/refs/tags/go1.19.4:src/go/printer/printer.go;drc=e76c87b1915cfbd0d4f22c6401987948af18e8c5;l=729)と呼ばれている）[^6]。

最後に、改行についても触れておきます。
token.Fileのところで、ast.Fileだけでは出力結果が決まらないと書きましたが、例えば、以下の2つのコードを[go/parser](https://pkg.go.dev/go/parser)の[`ParseFile`](https://pkg.go.dev/go/parser#ParseFile)でparseすると、中身が全く同じast.Fileが得られます。

```go
package p

func f() { }
```
```go
package p

func f() {
}
```

しかし、これらを `go fmt` した結果は、以下のように異なります。
```go
package p

func f() {}
```
```go
package p

func f() {
}
```

前後のtokenの種類によって、処理がまちまち（かつ複雑）で、ここですべてを説明することはできませんが、例えば上記のfunction bodyの例だと、[`bodySize`](https://cs.opensource.google/go/go/+/refs/tags/go1.19.4:src/go/printer/nodes.go;l=1774-1777)という関数の中で、tokenの行番号をチェックすることで、最終的な出力結果を変えています。
> ```go
> if pos1.IsValid() && pos2.IsValid() && p.lineFor(pos1) != p.lineFor(pos2) {
>     // opening and closing brace are on different lines - don't make it a one-liner
>     return maxSize + 1
> }
> ```

この行番号の情報は、ast.Fileは持っておらず、printerは、ソースファイルに対応するtoken.File（直接的には、token.FileSet）を参照して、これを取得しているというわけです。

さて、ここまで見てきた内容から、次のことが分かります。
1. tokenの位置を書き換えた場合、コメントの位置がずれる可能性がある（コメントの位置も更新する必要がある）
1. tokenの位置を書き換えた場合、行番号の判定処理が正しくなくなる（token.Fileを更新する必要がある）

以上を踏まえて、いよいよgoimportsの処理内容を見ていきます。

### goimports
#### グルーピング
`sortImports`内の処理が関係していますが、[ImportSpecの行番号が2以上ずれたらグループ分けをしています](https://cs.opensource.google/go/x/tools/+/refs/tags/v0.4.0:internal/imports/sortimports.go;l=45-49)。
> ```go
> if j > i && tokFile.Line(s.Pos()) > 1+tokFile.Line(d.Specs[j-1].End()) {
>     // j begins a new run.  End this one.
>     specs = append(specs, sortSpecs(localPrefix, tokFile, f, d.Specs[i:j])...)
>     i = j
> }
> ```

間が空行であるかは確認していないので、コメント行が間に挟まっていたとしても、グループ分けされてしまいます。
とはいえ、これがダメとも言えないわけで、もしこれを嫌うなら、少なくとも`ImportSpec.Doc`に入るコメント位置の調整を行う必要があり、処理が複雑になります。

#### 並べ替え
line commentはちゃんと一緒に並べ替えてくれてそうでしたが、実際[コメントと一緒に位置を変えています](https://cs.opensource.google/go/x/tools/+/refs/tags/v0.4.0:internal/imports/sortimports.go;l=216-236)。

が、今書いていて気がつきましたが、`ImportSpec.Comment` が[一行のコメントであることを仮定](https://cs.opensource.google/go/x/tools/+/refs/tags/v0.4.0:internal/imports/sortimports.go;l=168)してますね（実際は、複数行コメントが入ることもある）。

```go
import (
	"fmt" // fmt
	"context" /* context
	*/
)
```
↓
```go
import (
	"context"
	"fmt" // fmt
	/* context
	 */)
```

しかし、goimportsからすると、複数行コメントが一緒に移動すると、整形後のコードにおいて`context`と`fmt`は別のグループになってしまうので、これで正しいのかもしれません。難しい……

閑話休題、ImportSpec.Docは見ていないので、これらのコメントは、元の場所に置き去りにされます。

#### マージ
import declarationのマージ処理は、[`mergeImports`が行っています](https://cs.opensource.google/go/x/tools/+/refs/tags/v0.4.0:internal/imports/sortimports.go;l=88-92)。
> ```go
> // Move the imports of the other import declaration to the first one.
> for _, spec := range gen.Specs {
>     spec.(*ast.ImportSpec).Path.ValuePos = first.Pos()
>     first.Specs = append(first.Specs, spec)
> }
> ```

いや〜潔いです。後続のImportDeclに含まれていたImportSpecの位置を、全て最初のImportDeclの`Pos()`に変えています。ただし、全てのImportSpecが同じ位置にあることは、実際にはありえないので、ASTのデータとしては問題ないにせよ、これを文字列として出力すれば、コメントや改行の位置は当然破綻します。

ちなみに、この件については、[`mergeImports`のコメント](https://cs.opensource.google/go/x/tools/+/refs/tags/v0.4.0:internal/imports/sortimports.go;l=65-67)にも、ちゃんと[^7]書かれています[^8]。
> ```go
> // mergeImports merges all the import declarations into the first one.
> // Taken from golang.org/x/tools/ast/astutil.
> // This does not adjust line numbers properly
> ```

この方法は、潔さの他にもう一つ良い点があり、ImportDecl以外のDeclに影響を（おそらく）与えません。つまり、他のDeclとtoken.Fileの改行位置が整合するので、これによって、ImportDecl以外の出力結果をめちゃくちゃにせずに済んでいます。

[^5]: 実際は、`format.Source`も呼んでいますが、内部的にはこちらも`Config.Fprint`を使っています
[^6]: `printer.spec`などで、[`printer.setComment`](https://cs.opensource.google/go/go/+/refs/tags/go1.19.4:src/go/printer/nodes.go;l=1635)が呼ばれていて、Nodeに紐付いたコメントは適切な位置に出力されるようにしているように見えますが、ast.Fileのフォーマットを行っている時には、[`printer.setComment`は何もしません](https://cs.opensource.google/go/go/+/refs/tags/go1.19.4:src/go/printer/nodes.go;l=71-73;drc=e76c87b1915cfbd0d4f22c6401987948af18e8c5)。
[^7]: exportedでないfunctionのコメントという点に目をつぶれば
[^8]: `Taken from golang.org/x/tools/ast/astutil` というのがなかなか趣深いですが、逆に言うと、astutilの関数は行番号を破壊します（token.Fileを見ていないので当然ですが）。

## goimportsの悩み
まとめると、goimportsは以下のような問題を抱えています。

1. goimportsは一行コメント[^9]以外を無視している
1. その結果、ImportSpecの `Doc` に入っていたコメントが、フォーマット後にあらぬ場所に行ってしまう
1. astutilの関数の呼び出しや、それに準ずる処理が行われた場合、一行コメントもあらぬ場所に行ってしまう
1. （詳しく触れていないものの）改行位置を参照する以外の目的で行番号を取得しており、Goとして適格な一部のコードを受け付けない

表面的には、
1. 並べ替えの時に、コメントをあまりうまく扱えていないように見える
1. コメントが間に入ると、別のグループとして扱われてしまい、並べ替えてくれない

のが問題と言えます。

少なくとも後者については、ImportSpecの`Doc`にコメントが入っている限り、一緒に移動させるのが自然であり、現行の動きが正しいようには思えませんが、問題はもう少し複雑です。

例として、ImportSpecの`Doc`を尊重することで、グルーピングの挙動を改善[^10]させられるか考えてみます。
goimportsはマージをサポートしているため、
```go
/* fmt */ import "fmt"

// fmt
import "fmt"
```

というコード片を、以下のように変換します。
```go
/* fmt */
import (
	"fmt"
)

// fmt
```

これは、もともと `Doc` として扱われていた `// fmt` というコメントを捨てて、`Doc`ではなかった `/* fmt */` というコメントが`Doc`として扱われるようにする動きです。

では、`// fmt`も一緒に、以下のようにマージするのはどうでしょうか？
```go
// fmt
/* fmt */ import "fmt"
```

実は、現行のgo/parserの動きを前提にすると、上記のコードにおいて、`// fmt`も`/* fmt */`も`Doc`ではなくなっているのです。
つまり、ImportSpecの`Doc`を参照するだけでは、一度は「うまく」グルーピングできたとしても、その出力結果は、出力前と同じ意味[^11]に解釈されない可能性があります[^12]。

また、より根源的なところで、そもそもgo/printerは、変換後のソースコードをparseして得られるast.Fileが、元のast.Fileと（位置の違いを除いて）同じになることを保証していないため、`Doc`や`Comment`に頼るのでは、問題は解決できないように思われます。

### 結論
- コメントが何に対するコメントなのか、本当のところは書いた本人にしか分からない[^13]
- goimportsとしては、ユーザーが後からコメントを移動した時に、その変更を受け付けてあげることが重要
- import declarationのNodeがtoken.Fileと不整合になることはあるが、それ以外のNodeを壊さないようにしていて偉い

[^9]: line comment + 行末に一行で書かれているgeneral comment
[^10]: ここでは、コメント行は尊重して、空行でのみグルーピングを行う動作に変えること。本当に改善されたと感じるかは、主観による
[^11]: といっても、go/parserにとっての話で、プログラムとしてのsemanticsは同じ
[^12]: 基本的には処理はべき等で、意味が変わったところで出力は変わらない
[^13]: まれに本人にも分からないことがある

## すべての悩みを消し去りたい、この手で
誰がどういう時にどういう意図でどこにコメントを書くか、知る由もないので、すべてのケースでユーザーの意図通りに動くformatterを作ることはおそらく不可能でしょう。

不可能でしょう……
不可能でしょうけど、やっぱりもう少しいい感じに動いてほしいんだよなー。

というのは、色んな人が感じているようで、[issueが立ったり](https://github.com/golang/go/issues/20818)、いろんなツールが書かれたりしています（やっぱりみんな大好きなんですね）。

代表的なところで、[gosimports](https://github.com/rinchsan/gosimports)というのがあり、これは一切のコメントを消し去る代わりに、グルーピングが一意になるようにしています。
これはこれで潔い。
でも、 `//lint:ignore` とか書きたいことはないですか……？

ということで、もう一つ生やしてしまいました。
https://github.com/homuler/goimports-wasabi

コメントの位置を、以下のように可能な限り分解して、マージや並べ替えが発生しても、大まかな位置を維持できるようにしています。
```go
// (1)
/*(2)*/ import /*(3)*/ _ /*(4)*/ "fmt" // (5)
// (6)

// (7)

// (8)
/*(9)*/ import /*(10)*/ ( // (11)
    // (12)

    // (1)'
    /*(3)'*/ e /*(4)'*/ "errors" // (5)'
    // (6)'

    // (13)
) // (14)
// (15)
```

例えば、これが
```go
// doc comment for fmt
import "fmt"

// doc comment for context
import "context"

// doc comment
import (
	// doc comment for errors
	"errors"
)
```
↓
```go
// doc comment
import (
	// doc comment for context
	"context"
	// doc comment for errors
	"errors"
	// doc comment for fmt
	"fmt"
)
```
こうなります。

ちなみに、改行位置は、ソースコードを再構成したあとに[File.SetLinesForContent](https://pkg.go.dev/go/token#File.SetLinesForContent)を呼ぶことで、整合性を保っています。

goplsが使っているAPIは実装しているので、ごにょごにょすれば、一応goplsに組み込んで動かすこともできます。

`format.Source`を使って出力していた頃は、なぜかgoimportsより30%ぐらいパフォーマンスが良かったものの、`format.Node`に変えたら、これまたなぜかgoimportsよりパフォーマンスが落ちたので、冬休みになんとかする予定です。

## （おまけ）Gofmtの悩み
goimportsは、内部でGofmtと共通のAPIを使っていますが、そんなGofmtにも悩みがあります（知らんけど）。

みんな大好きなGofmt、その動作内容からして、処理がべき等（idempotent）であるはずだと信じていた方もいるのではないかと思いますが、1.19.4時点で[べき等ではありません](https://github.com/golang/go/issues/24472)（信じてたのに、裏切られたの？私も同じ気持ちです）。

## ライセンス
記事内で、[go/tools](https://cs.opensource.google/go/x/tools)（[BSD-3-Clause](https://cs.opensource.google/go/x/tools/+/master:LICENSE)）と[go/go](https://cs.opensource.google/go/go)（[BSD-3-Clause](https://cs.opensource.google/go/go/+/master:LICENSE)）のコードを一部引用しています。
Copyright (c) 2009 The Go Authors. All rights reserved.

## そもそもimport文にコメント……
それ以上はいけない

<hr/>

明日は @BlueRose_Sora さんの記事です。
(っ ॑꒳ ॑c)ﾜｸﾜｸ