Goのスコープについて考えてみよう #golang

## はじめに

Twitterで以下のような投稿をしてみました。

<img src="https://qiita-image-store.s3.amazonaws.com/0/14952/0c2f4616-5e8f-47f1-75a2-3ab9df21edca.png" width="400px">
https://twitter.com/tenntenn/status/815807925222412292

この問題は、以下のコード中に存在するスコープの数を聞いている問題です。

```go
package main

import "fmt"

func main() {
	const message = "hello, world"
	fmt.Println(message)
}
```

まだ回答してない方は、ぜひここでいくつになるか考えてみてください。

さて、ここでヒントを出しましょう。
以下のコードをみてみましょう。

```go
package main

import (
	myfmt "fmt"
)

func main() {
	var string string = "HELLO"
	myfmt.Println(string)
}
```

このコードに存在する識別子は、どのスコープに存在するでしょう？
`myfmt`はどの範囲で使えるでしょうか？
組込み型の`string`は？一方で変数の`string`は？
それぞれの識別子の有効範囲を考えてみると、自ずと分かってくるかと思います。

それでは答えを考えていきましょう。

なお、この記事を書いた時点でのGoの最新バージョンはGo1.7.4です。

## `go/types`パッケージを使って識別子が存在するスコープを探す

さて、答えあわせといきたいところですが、せっかくなので[`go/types`](https://golang.org/pkg/go/types/)パッケージを使って、それぞれの識別子が定義されているスコープを取得してみたいと思います。

まずは、対象となるコードをパースしてASTを取得しましょう。
ここでは[`parser.ParseFile`](https://golang.org/pkg/go/parser/#ParseFile)関数を使っています。
詳しいASTの取得の方法は、「[ASTを取得する方法を調べる](http://qiita.com/tenntenn/items/13340f2845316532b55a)」という記事に書いていますので、そちらを参考にしてください。

```go
fset := token.NewFileSet()
f, err := parser.ParseFile(fset, "sample.go", src, 0)
if err != nil {
	log.Fatalln("Error:", err)
}
```

さて、ファイルを表すASTのノードである[`ast.File`](https://golang.org/pkg/go/ast/#File)が手に入ったので（ここでは`f`という変数）、`go/types`パッケージが提供する型チェッカーにかけ、パッケージ情報を取得してみます。

```go
conf := types.Config{Importer: importer.Default()}
pkg, err := conf.Check("main", fset, []*ast.File{f}, nil)
if err != nil {
	log.Fatalln("Error:", err)
}
```

[`types.Config`](https://golang.org/pkg/go/types/#Config)構造体は型チェッカーの設定を保持する構造体で、ここでは`Importer`フィールドを指定しています。[`types.Importer`](https://golang.org/pkg/go/types/#Importer)インタフェースは、インポートパスからパッケージ情報を取得する機能を提供するインタフェースです。
なお、パッケージ情報は[`types.Pacakge`](https://golang.org/pkg/go/types/#Package)構造体で表されます。

`*types.Config`型の[`Check`](https://golang.org/pkg/go/types/#Config.Check)メソッドは、型チェックを行うメソッドで以下の3つの機能を提供します。

* 識別子の解決（identifier resolution）
* 型推論（type deduction）
* 定数の評価（constant evaluation）

第1引数は、対象とするパッケージのインポートパスで、今回は`main`としています。
そして第2引数には、パッケージを構成するファイルの情報をASTのノード（`*ast.File`型）のスライスとして渡します。
最後に、第3引数には`types.Info`構造体のポインタを渡すのですが、ここでは不要なので`nil`にしてあります。
もし、識別子の使用場所や定義場所などの情報を欲しい場合は、`Uses`フィールドや`Defs`フィールドのマップを初期化して渡すと、そこに解析結果が入れられます。

`Check`メソッドの戻り値は、パッケージ情報である`type.Pacakge`構造体のポインタが取得できます。
今回はここから取得できるスコープの情報を使用して、各識別子のスコープを取得します。

さて、今回対象とするファイル中に登場する識別子をすべて取得するには、[`ast.Inspect`](https://golang.org/pkg/go/ast/#Inspect)関数を使うのが手っ取り早いでしょう。
なお、`ast.Inspect`関数についての詳細は、「[抽象構文木（AST）をトラバースする](http://qiita.com/tenntenn/items/f029425a844687a0e64b)」という記事に書いてありますのでぜひ参考にしてください。

```go
ast.Inspect(f, func(n ast.Node) bool {
	if ident, ok := n.(*ast.Ident); ok {
		// TODO: 識別子のスコープを取得する
	}
	return true
})
```

上記のコードには、一番大切な各識別子が定義されたスコープを取得するコードがありません。
どうすれば、取得できるのでしょうか？

`go/types`パッケージでは、スコープは、[`types.Scope`](https://golang.org/pkg/go/types/#Scope)構造体として定義されています。
そして、スコープは木構造体を形成しているので、[`Child`](https://golang.org/pkg/go/types/#Scope.Child)メソッドや[`Parent`](https://golang.org/pkg/go/types/#Scope.Parent)で子や親のスコープを取得できます。

`*types.Config`型の`Check`メソッドの戻り値である、`*types.Package`型からは`Scope`メソッドを呼ぶことで、パッケージスコープが取得できます。
今回対象とするコードで定義された識別子は、パッケージスコープより下にあることは予想されます。
また、`*types.Scope`型の`InnerMost`メソッドを使うことで、指定した位置を内包するスコープのうち最も内側にあるスコープを、メソッドのレシーバであるスコープ以下のスコープ（内側のスコープ）から探します。
そのため、一度識別子が登場した場所を含む最も内側のスコープを探し、そこからその識別子が定義されているスコープを親を辿っていきながら探します。
これは、同じ識別子でも、内側のスコープで定義された識別子が優先されることと一致しています。
`*types.Scope`型の`LookupParent`メソッドを使うと、親を辿って対応する識別子のスコープを探すことができます。

上記の処理をコードにすると以下のようになります。

```go
innerMost := pkg.Scope().Innermost(ident.Pos())
s, _ := innerMost.LookupParent(ident.Name, ident.Pos())
```

`innerMost`は`ident`が登場した場所のもっとも内側にあるスコープを表します。
そして、`LookupParent`メソッドで、`innerMost`から親を辿っていき、`ident`の定義されたスコープを探します。
なお、`LookupParent`メソッドの第2戻り値には、[`types.Object`](https://golang.org/pkg/go/types/#Object)型の値が返されますが、ここでは使用しないため`_`に代入しています。

さて、上記の処理で取得した`s`がいくつあるかがこの問題を解く鍵です。
ここまで出てきたコードを実行可能なようにすべて載せておきます。

```go
package main

import (
	"fmt"
	"go/ast"
	"go/importer"
	"go/parser"
	"go/token"
	"go/types"
	"log"
)

// sample.go
const src = `package main

import "fmt"

func main() {
	const message = "hello, world"
	fmt.Println(message)
}`

func main() {
	fset := token.NewFileSet()
	f, err := parser.ParseFile(fset, "sample.go", src, 0)
	if err != nil {
		log.Fatalln("Error:", err)
	}

	conf := types.Config{Importer: importer.Default()}
	pkg, err := conf.Check("main", fset, []*ast.File{f}, nil)
	if err != nil {
		log.Fatalln("Error:", err)
	}

	scopes := map[*types.Scope]struct{}{}
	ast.Inspect(f, func(n ast.Node) bool {
		if ident, ok := n.(*ast.Ident); ok {
			innerMost := pkg.Scope().Innermost(ident.Pos())
			s, _ := innerMost.LookupParent(ident.Name, ident.Pos())
			if s != nil {
				scopes[s] = struct{}{}
			}
		}
		return true
	})

	fmt.Println("====", len(scopes), "scopes ====")
	for s := range scopes {
		fmt.Println(s)
	}
}
```

`scopes`をマップにし、キーを`*types.Scope`型の値にすることで、重複なくスコープを取得するようにしています。
上記のコードを実行すると以下のように表示されるでしょう。
なおこのコードは、The Go Playground上では、`importer.Default`関数で取得できる`types.Importer`がうまく動かないので実行できません。

```
==== 3 scopes ====
package "main" scope 0x4203ff6d0 {
.  func main.main()
}
sample.go scope 0x4203ff7c0 {
.  package fmt
}
function scope 0x42053d630 {
.  const message untyped string
}
```

このコードで出てくる識別子が定義されている以下のスコープは`3`つのようです！

* `main`パッケージのスコープ
* ファイル(`sample.go`)スコープ
* `main`関数のスコープ

出力結果を見れば分かる通り、ファイルスコープでは、`import`した際に割り当てられるパッケージの識別子が定義されます。ここでは、`fmt`がそれにあたります。
よく考えてみると、ファイルごとに`import`文は書くため、この結果には納得できると思います。

さて、冒頭で挙げた問題の答えば`3`つが正解でしょうか！？
でもよく考えてみると、何かおかしいです。
解析したコードには、組込み関数や組込み型が一切使われていません。
これらを表す`panic`や`int`などの識別子はどのスコープで定義されているのでしょうか？

## ユニバーススコープ

実は組込み関数や組込み型、そして`true`や`false`などの定数はユニバーススコープというスコープで定義されています。
このスコープは、どんなGoのコードでも存在し、すべてのスコープのルートとなるスコープです。
ユニバーススコープは[`types.Universe`](https://golang.org/pkg/go/types/#Universe)という変数で定義されています。
なお変数として定義する便宜上、すべてのルートとなるスコープですが、`Child`メソッドからは子となるスコープは取得できません。

では、組込み型を使用する以下のコードを先程の解析プログラムにかけて結果をみてみましょう。

```go
package main

import (
	myfmt "fmt"
)

func main() {
	var string string = "HELLO"
	myfmt.Println(string)
}
```

結果は以下のようになります。

```
==== 4 scopes ====
package "main" scope 0x4203ff6d0 {
.  func main.main()
}
sample.go scope 0x4203ff7c0 {
.  package myfmt ("fmt")
}
universe scope 0x4203fe1e0 {
.  builtin append
.  type bool bool
.  type byte byte
.  builtin cap
.  builtin close
.  builtin complex
.  type complex128 complex128
.  type complex64 complex64
.  builtin copy
.  builtin delete
.  type error interface{Error() string}
.  const false untyped bool
.  type float32 float32
.  type float64 float64
.  builtin imag
.  type int int
.  type int16 int16
.  type int32 int32
.  type int64 int64
.  type int8 int8
.  const iota untyped int
.  builtin len
.  builtin make
.  builtin new
.  nil
.  builtin panic
.  builtin print
.  builtin println
.  builtin real
.  builtin recover
.  type rune rune
.  type string string
.  const true untyped bool
.  type uint uint
.  type uint16 uint16
.  type uint32 uint32
.  type uint64 uint64
.  type uint8 uint8
.  type uintptr uintptr
}
function scope 0x42053d630 {
.  var string string
}
```

ユニバーススコープを含めて4つのスコープが存在することが分かるかと思います。
`fmt`パッケージに別名をつけた`myfmt`がちゃんとファイルスコープで定義されているのも分かりますね。

実は、スコープには以下の4種類があります。

* ユニバース
* ファイル
* パッケージ
* ローカル

そして、それぞれの種類のスコープでは以下のオブジェクト([`types.Object`](https://golang.org/pkg/go/types/#Object)に対応する)が定義できます。

| | ユニバース | ファイル | パッケージ | ローカル |
|:------------------:|:-:|:-:|:-:|:-:|
|組込み関数([`types.Bultin`](https://golang.org/pkg/go/types/#Builtin)) | ✔ |   |   |   | |
|`nil`([`types.Nil`](https://golang.org/pkg/go/types/#Nil))        | ✔ |   |   | |
|定数([`types.Const`](https://golang.org/pkg/go/types/#Const))        |✔| |✔|✔|
|型名([`types.TypeName`](https://golang.org/pkg/go/types/#TypeName))     |✔| |✔|✔|
|関数([`types.Func`](https://golang.org/pkg/go/types/#Func))         | | |✔| |
|変数([`types.Var`](https://golang.org/pkg/go/types/#Var))          | | |✔|✔|
|パッケージ名([`types.PkgName`](https://golang.org/pkg/go/types/#PkgName))| |✔| | |
|ラベル([`Label`](https://golang.org/pkg/go/types/#Label))       | | | |✔|

## おわりに

さて、長々と説明してきましたが、答えは`4`つです！
今回の問題は「[go/types: The Go Type Checker](https://github.com/golang/example/tree/master/gotypes)」というドキュメント中に[出てくる](https://github.com/golang/example/blob/master/gotypes/README.md#scopes)ものを参考にしました。
このドキュメントは`go/types`パッケージについて詳しく書いてあり、Goに関する知識も身につくため、ぜひ読んでみてください。
なお、読むためにはある程度、他の`go`パッケージについても知っておく必要があるため、`go/parser`パッケージや`go/ast`パッケージくらいは触っておいた方が良さそうです。
これらのパッケージについて知りたい方は公式ドキュメントを読むか、私の他のQiitaの記事で`go`パッケージについて書いているので、ぜひそちらも読んでみてください。

ちなみに私は最初`2`つだと思ってました！まだまだですね！