RubyVM::AbstractSyntaxTree::Node 詳細

この記事は [Okinawa.rb Advent Calendar 2018](https://qiita.com/advent-calendar/2018/okinawarb) の24日目の記事です。

## RubyVM::AbstractSyntaxTree について

Ruby 2.6 では `RubyVM::AbstractSyntaxTree` が導入され Ruby のソースコードを Ruby のデータ構造として扱えるようになります。解析した結果では様々な `RubyVM::AbstractSyntaxTree::Node` オブジェクトが作成され、下記の値を取得することが出来ます。

| method       | 説明                         | Class   |
|:-------------|:-----------------------------|:--------|
| type         | ノードの種別                 | Symbol  |
| children     | ノードが持つ子ノードの一覧   | Array   |
| first_column | ノードの開始位置のカラム番号 | Integer |
| first_lineno | ノードの開始位置の行番号     | Integer |
| last_column  | ノードの終了位置のカラム番号 | Integer |
| last_lineno  | ノードの終了位置の行番号     | Integer |


`children` は Node の種類によって各要素で取得出来る値が異なるのでそれを調べてみました。

ノードの種類については `node.c` と `node.h` を参考に調べています。

https://github.com/ruby/ruby/blob/ruby_2_6/node.c
https://github.com/ruby/ruby/blob/ruby_2_6/node.h


まだ調査中のものもありますがご了承ください。


## SCOPE

新しいスコープが生成されるたびに定義される。

| index | 説明          | Class                            |
|:------|:--------------|:---------------------------------|
| 0     | 変数の情報    | Array                            |
| 1     | 引数の一覧    | Array                            |
| 2     | 本体          | RubyVM::AbstractSyntaxTree::Node |


## BLOCK

連続した式や文を表す。 `children` の各要素にはそれぞれ式や文の情報が入っている。

| index | 説明          | Class                            |
|:------|:--------------|:---------------------------------|
| n     | 式や文の情報  | RubyVM::AbstractSyntaxTree::Node |


## IF

if 式を表す。

| index | 説明                   | Class                            |
|:------|:-----------------------|:---------------------------------|
| 0     | if の条件式            | RubyVM::AbstractSyntaxTree::Node |
| 1     | 条件式が真の場合の本体 | RubyVM::AbstractSyntaxTree::Node |
| 2     | 条件式が偽の場合の本体 | RubyVM::AbstractSyntaxTree::Node or NilClass |


```ruby
if x == 1
  foo
else
  bar
end
```

```
(IF@1:0-5:3
   (OPCALL@1:3-1:9 (VCALL@1:3-1:4 :x) :== (ARRAY@1:8-1:9 (LIT@1:8-1:9 1) nil))
   (VCALL@2:2-2:5 :foo) (VCALL@4:2-4:5 :bar))
```


## UNLESS

unless 式を表す。

| index | 説明            | Class                                        |
|:------|:----------------|:---------------------------------------------|
| 0     | unless の条件式 | RubyVM::AbstractSyntaxTree::Node             |
| 1     | 偽の場合の式    | RubyVM::AbstractSyntaxTree::Node             |
| 2     | 真の場合の式    | RubyVM::AbstractSyntaxTree::Node or NilClass |


```ruby
unless x == 1
  foo
else
  bar
end
```

```
(UNLESS@1:0-5:3
   (OPCALL@1:7-1:13 (VCALL@1:7-1:8 :x) :==
      (ARRAY@1:12-1:13 (LIT@1:12-1:13 1) nil)) (VCALL@2:2-2:5 :foo)
   (VCALL@4:2-4:5 :bar))
```


## CASE

case 式

| index | 説明            | Class                            |
|:------|:----------------|:---------------------------------|
| 0     | 条件式          | RubyVM::AbstractSyntaxTree::Node |
| 1     | 次の when 句    | RubyVM::AbstractSyntaxTree::Node |


```ruby
case x
when 1
  foo
else
  baz
end
```

```
(CASE@1:0-6:3 (VCALL@1:5-1:6 :x)
   (WHEN@2:0-5:5 (ARRAY@2:5-2:6 (LIT@2:5-2:6 1) nil) (VCALL@3:2-3:5 :foo)
      (VCALL@5:2-5:5 :baz)))
```


## CASE2

case 式の条件が無い場合

| index | 説明            | Class                            |
|:------|:----------------|:---------------------------------|
| 0     | 条件式          | NilClass                         |
| 1     | 次の when 句    | RubyVM::AbstractSyntaxTree::Node |


```ruby
case
when 1
  foo
else
  baz
end
```

```
(CASE2@1:0-6:3 nil
   (WHEN@2:0-5:5 (ARRAY@2:5-2:6 (LIT@2:5-2:6 1) nil) (VCALL@3:2-3:5 :foo)
      (VCALL@5:2-5:5 :baz)))
```


## WHEN

| index | 説明                     | Class                                        | 備考                         |
|:------|:-------------------------|:---------------------------------------------|:-----------------------------|
| 0     | when 句 にある式のリスト | RubyVM::AbstractSyntaxTree::Node             |                              |
| 1     | 本文                     | RubyVM::AbstractSyntaxTree::Node             |                              |
| 2     | 次の when 句             | RubyVM::AbstractSyntaxTree::Node or NilClass | 次の句が存在しない場合は nil |


## WHILE

`while` 文を表す

| index | 説明         | Class                            |
|:------|:-------------|:---------------------------------|
| 0     | 条件式       | RubyVM::AbstractSyntaxTree::Node |
| 1     | while の中身 | RubyVM::AbstractSyntaxTree::Node |


```ruby
while x == 1
  foo
end
```

```
(WHILE@1:0-3:3
   (OPCALL@1:6-1:12 (VCALL@1:6-1:7 :x) :==
      (ARRAY@1:11-1:12 (LIT@1:11-1:12 1) nil)) (VCALL@2:2-2:5 :foo))
```

## UNTIL

`until` 文を表す

| index | 説明         | Class                            |
|:------|:-------------|:---------------------------------|
| 0     | 条件式       | RubyVM::AbstractSyntaxTree::Node |
| 1     | until の中身 | RubyVM::AbstractSyntaxTree::Node |


```ruby
until x == 1
  foo
end
```

```
(UNTIL@1:0-3:3
   (OPCALL@1:6-1:12 (VCALL@1:6-1:7 :x) :==
      (ARRAY@1:11-1:12 (LIT@1:11-1:12 1) nil)) (VCALL@2:2-2:5 :foo))
```


## ITER

ブロック付きのメソッド呼び出し

| index | 説明                         | Class                            |
|:------|:-----------------------------|:---------------------------------|
| 0     | 呼び出しているメソッドの情報 | RubyVM::AbstractSyntaxTree::Node |
| 1     | ブロック本体                 | RubyVM::AbstractSyntaxTree::Node |


## FOR

for 文を表す。

| index | 説明                         | Class                            |
|:------|:-----------------------------|:---------------------------------|
| 0     | 繰り返し処理の対象になる部分 | RubyVM::AbstractSyntaxTree::Node |
| 1     | for 文の本文                 | RubyVM::AbstractSyntaxTree::Node |


## FOR_MASGN

TBD

## BREAK

`break` を表す

| index | 説明           | Class                                        |                          |
|:------|:---------------|:---------------------------------------------|:-------------------------|
| 0     | ループの戻り値 | RubyVM::AbstractSyntaxTree::Node or NilClass | 何も指定しない場合は nil |


```ruby
break
```

```
(BREAK@1:0-1:5 nil)
```


## NEXT

`next` を表す

| index | 説明           | Class                                        |                          |
|:------|:---------------|:---------------------------------------------|:-------------------------|
| 0     | ループの戻り値 | RubyVM::AbstractSyntaxTree::Node or NilClass | 何も指定しない場合は nil |


```ruby
next
```

```
(NEXT@1:0-1:4 nil)
```


## REDO

特になし

```ruby
redo
```

```
(REDO@1:0-1:4)
```


## RETRY

特になし

```ruby
retry
```

```
(RETRY@1:0-1:5)
```


## BEGIN

| index | 説明     | Class                                        | 備考                 |
|:------|:---------|:---------------------------------------------|:---------------------|
| 0     | 本体     | RubyVM::AbstractSyntaxTree::Node or NilClass | 本体が無い場合は nil |


## RESCUE

rescue 句

| index | 説明                | Class                                        |
|:------|:--------------------|:---------------------------------------------|
| 0     | begin句の中身       | RubyVM::AbstractSyntaxTree::Node             |
| 1     | resuce句の中身      | RubyVM::AbstractSyntaxTree::Node             |
| 2     | else句の中身        | RubyVM::AbstractSyntaxTree::Node or NilClass |


## RESBODY

resuce 句の中身

| index | 説明                     | Class                            |
|:------|:-------------------------|:---------------------------------|
| 0     | 指定されている例外の一覧 | RubyVM::AbstractSyntaxTree::Node |
| 1     | resuce句の中身           | RubyVM::AbstractSyntaxTree::Node |
| 2     | 次の rescue 句           | RubyVM::AbstractSyntaxTree::Node |


## ENSURE

| index | 説明                | Class                            |
|:------|:--------------------|:---------------------------------|
| 0     | ensure の 1つ前の句 | RubyVM::AbstractSyntaxTree::Node |
| 1     | ensure の本文       | RubyVM::AbstractSyntaxTree::Node |
    
## AND

`&&` または `and`

| index | 説明     | Class                            |
|:------|:---------|:---------------------------------|
| 0     | 左辺     | RubyVM::AbstractSyntaxTree::Node |
| 1     | 右辺     | RubyVM::AbstractSyntaxTree::Node |


```ruby
foo && bar
```

```
(AND@1:0-1:10 (VCALL@1:0-1:3 :foo) (VCALL@1:7-1:10 :bar))
```


## OR

`||` または `or`

| index | 説明     | Class                            |
|:------|:---------|:---------------------------------|
| 0     | 左辺     | RubyVM::AbstractSyntaxTree::Node |
| 1     | 右辺     | RubyVM::AbstractSyntaxTree::Node |

```ruby
foo || bar
```

```
(OR@1:0-1:10 (VCALL@1:0-1:3 :foo) (VCALL@1:7-1:10 :bar))
```


## MASGN

複数の変数代入

| index | 説明     | Class                                        |
|:------|:---------|:---------------------------------------------|
| 0     | 右辺     | RubyVM::AbstractSyntaxTree::Node or NilClass |
| 1     | 左辺     | RubyVM::AbstractSyntaxTree::Node or NilClass |
| 2     | splat    | RubyVM::AbstractSyntaxTree::Node             |


## LASGN

変数への代入

| index | 説明     | Class                            |
|:------|:---------|:---------------------------------|
| 0     | 変数名   | Symbol                           |
| 1     | 値       | RubyVM::AbstractSyntaxTree::Node |

```ruby
x = 1
```

```
(LASGN@1:0-1:5 :x (LIT@1:4-1:5 1))
```


## DASGN

動的な変数代入 (変数はスコープ外で定義されたもの)

| index | 説明     | Class                            |
|:------|:---------|:---------------------------------|
| 0     | 変数名   | Symbol                           |
| 1     | 値       | RubyVM::AbstractSyntaxTree::Node |


## DASGN_CURR

動的な変数代入 (ブロック内のスコープで定義された変数)

| index | 説明     | Class                            |
|:------|:---------|:---------------------------------|
| 0     | 変数名   | Symbol                           |
| 1     | 値       | RubyVM::AbstractSyntaxTree::Node |


## GASGN

グローバル変数への代入

| index | 説明     | Class                            |
|:------|:---------|:---------------------------------|
| 0     | 変数名   | Symbol                           |
| 1     | 値       | RubyVM::AbstractSyntaxTree::Node |


```ruby
$foo = 4
```

```
(GASGN@1:0-1:8 :$foo (LIT@1:7-1:8 4))
```


## IASGN

インスタンス変数への代入

| index | 説明     | Class                                        | 備考                 |
|:------|:---------|:---------------------------------------------|:---------------------|
| 0     | 変数名   | Symbol                                       |                      |
| 1     | 値       | RubyVM::AbstractSyntaxTree::Node or NilClass | 多重代入の場合は nil |

```ruby
@foo = 1
```

```
(IASGN@1:0-1:8 :@foo (LIT@1:7-1:8 1))
```


## CDECL

定数の宣言

名前空間なし

| index | 説明     | Class                            |
|:------|:---------|:---------------------------------|
| 0     | 変数名   | Symbol                           |
| 1     | 値       | RubyVM::AbstractSyntaxTree::Node |

名前空間あり

| index | 説明     | Class                            |
|:------|:---------|:---------------------------------|
| 0     | 名前空間 | RubyVM::AbstractSyntaxTree::Node |
| 1     | 変数名   | Symbol                           |
| 2     | 値       | RubyVM::AbstractSyntaxTree::Node |


```ruby
FOO = 1
```

```
(CDECL@1:0-1:7 :FOO (LIT@1:6-1:7 1))
```


## CVASGN

クラス変数への代入

| index | 説明     | Class                            |
|:------|:---------|:---------------------------------|
| 0     | 変数名   | Symbol                           |
| 1     | 値       | RubyVM::AbstractSyntaxTree::Node |

```ruby
@@foo = 2
```

```
(CVASGN@1:0-1:9 :@@foo (LIT@1:8-1:9 2))
```


## OP_ASGN1

配列の要素への代入操作

| index | 説明       | Class                            |
|:------|:-----------|:---------------------------------|
| 0     | レシーバー | RubyVM::AbstractSyntaxTree::Node |
| 1     | オペランド | Symbol                           |
| 2     | 添字       | RubyVM::AbstractSyntaxTree::Node |
| 3     | 値         | RubyVM::AbstractSyntaxTree::Node |


## OP_ASGN2

フィールドに対する操作

| index | 説明         | Class                            |
|:------|:-------------|:---------------------------------|
| 0     | レシーバー   | RubyVM::AbstractSyntaxTree::Node |
| 1     | TBD          | TBD                              |
| 2     | フィールド名 | Symbol                           |
| 3     | 値           | RubyVM::AbstractSyntaxTree::Node |


## OP_ASGN_AND

`&&=`

| index | 説明     | Class                            |
|:------|:---------|:---------------------------------|
| 0     | 変数     | RubyVM::AbstractSyntaxTree::Node |
| 1     | 演算子名 | Symbol (`&&` で固定)             |
| 2     | 値       | RubyVM::AbstractSyntaxTree::Node |


```ruby
foo &&= bar
```

```
(OP_ASGN_AND@1:0-1:11 (LVAR@1:0-1:3 :foo) :"&&"
   (LASGN@1:0-1:11 :foo (VCALL@1:8-1:11 :bar)))
```

## OP_ASGN_OR

`||=`

| index | 説明     | Class                            |
|:------|:---------|:---------------------------------|
| 0     | 変数     | RubyVM::AbstractSyntaxTree::Node |
| 1     | 演算子名 | Symbol                           |
| 2     | 値       | RubyVM::AbstractSyntaxTree::Node |


```ruby
foo ||= bar
```

```
(OP_ASGN_OR@1:0-1:11 (LVAR@1:0-1:3 :foo) :"||"
   (LASGN@1:0-1:11 :foo (VCALL@1:8-1:11 :bar)))
```


## OP_CDECL

演算子付きの定数宣言

| index | 説明     | Class                            |
|:------|:---------|:---------------------------------|
| 0     | 変数     | RubyVM::AbstractSyntaxTree::Node |
| 1     | 演算子名 | Symbol                           |
| 2     | 値       | RubyVM::AbstractSyntaxTree::Node |

名前空間なしかつ `&&=` や `||=` で定義した場合は `OP_ASGN_AND` や `OP_ASGN_OR` で解釈される。

```ruby
A::B ||= 1
```

```
(OP_CDECL@1:0-1:10 (COLON2@1:0-1:4 (CONST@1:0-1:1 :A) :B) :"||"
   (LIT@1:9-1:10 1))
```


## CALL

メソッドの呼び出し

| index | 説明       | Class                                        | 備考             |
|:------|:-----------|:---------------------------------------------|:-----------------|
| 0     | レシーバー | RubyVM::AbstractSyntaxTree::Node             |                  |
| 1     | メソッド名 | Symbol                                       |                  |
| 2     | 引数       | RubyVM::AbstractSyntaxTree::Node or NilClass | 引数の有無で変化 |


```ruby
obj.foo(1)
```

```
(CALL@1:0-1:10 (VCALL@1:0-1:3 :obj) :foo (ARRAY@1:8-1:9 (LIT@1:8-1:9 1) nil))
```


## OPCALL

メソッドの呼び出し

| index | 説明       | Class                            |
|:------|:-----------|:---------------------------------|
| 0     | レシーバー | RubyVM::AbstractSyntaxTree::Node |
| 1     | メソッド名 | Symbol                           |
| 2     | 引数       | RubyVM::AbstractSyntaxTree::Node |


```ruby
foo + bar
```

```
(OPCALL@1:0-1:9 (VCALL@1:0-1:3 :foo) :+
   (ARRAY@1:6-1:9 (VCALL@1:6-1:9 :bar) nil))
```


## FCALL

関数呼び出し

| index | 説明       | Class                                        | 備考             |
|:------|:-----------|:---------------------------------------------|:-----------------|
| 0     | メソッド名 | Symbol                                       |                  |
| 1     | 引数       | RubyVM::AbstractSyntaxTree::Node or NilClass | 引数の有無で変化 |


```ruby
foo(1)
```

```
(FCALL@1:0-1:6 :foo (ARRAY@1:4-1:5 (LIT@1:4-1:5 1) nil))
```


## VCALL

引数なしの関数呼び出し。ただし、 `foo()` みたいな `()` がついている場合は `FCALL` として解釈される。

| index | 説明       | Class                            |
|:------|:-----------|:---------------------------------|
| 0     | メソッド名 | Symbol                           |

```ruby
foo
```

```
(VCALL@1:0-1:3 :foo)
```


## QCALL

ぼっち演算子 (`&.`) での呼び出し (Safe Navigation Operator)

| index | 説明       | Class                            |
|:------|:-----------|:---------------------------------|
| 0     | レシーバー | RubyVM::AbstractSyntaxTree::Node |
| 1     | メソッド名 | Symbol                           |
| 2     | 引数       | RubyVM::AbstractSyntaxTree::Node |


```ruby
obj&.foo(1)
```

```
(QCALL@1:0-1:11 (VCALL@1:0-1:3 :obj) :foo
   (ARRAY@1:9-1:10 (LIT@1:9-1:10 1) nil))
```


## SUPER

`super` の呼び出し

| index | 説明       | Class                                        | 備考                             |
|:------|:-----------|:---------------------------------------------|:---------------------------------|
| 0     | 引数       | RubyVM::AbstractSyntaxTree::Node or NilClass | `super()` で呼び出した場合は nil |

```ruby
super(1)
```

```
(SUPER@1:0-1:8 (ARRAY@1:6-1:7 (LIT@1:6-1:7 1) nil))
```


## ZSUPER

引数なしの `super` 呼び出し

特になし

```ruby
super
```

```
(ZSUPER@1:0-1:5)
```


## ARRAY

配列

| index | 説明       | Class |
|:------|:-----------|:------|
| 0     | 配列の要素 | Array |

最後の要素は `nil` なので、すべての要素は `[0..-2]` の範囲にある


## ZARRAY

空配列

特になし


```ruby
[]
```

```
(ZARRAY@1:0-1:2)
```


## VALUES

`return` の引数

| index | 説明           | Class             |
|:------|:---------------|:------------------|
| 0     | 返り値のリスト | Array or NilClass |

最後の要素は `nil` なので、すべての要素は `[0..-2]` の範囲にある

```ruby
return 1, 2, 3
```

```
(RETURN@1:0-1:14
   (VALUES@1:7-1:14 (LIT@1:7-1:8 1) (LIT@1:10-1:11 2) (LIT@1:13-1:14 3) nil))
```


## HASH

Hash

| index | 説明                | Class                                        |
|:------|:--------------------|:---------------------------------------------|
| 0     | Hash の要素のリスト | RubyVM::AbstractSyntaxTree::Node or NilClass |

要素は `[key, value, key, value, ...]` という形で入っている。空の場合は `nil` になる。


## RETURN

`return` 文

特になし

## YIELD

`yield` の呼び出し

| index | 説明     | Class                                        | 備考                 |
|:------|:---------|:---------------------------------------------|:---------------------|
| 0     | 引数     | RubyVM::AbstractSyntaxTree::Node or NilClass | 引数がない場合は nil |

```ruby
yield 1
```

```
(YIELD@1:0-1:7 (ARRAY@1:6-1:7 (LIT@1:6-1:7 1) nil))
```


## LVAR

ローカル変数の参照

| index | 説明     | Class                            |
|:------|:---------|:---------------------------------|
| 0     | 変数名   | Symbol                           |


```ruby
x = 1
x
```

```
(BLOCK@1:0-2:1 (LASGN@1:0-1:5 :x (LIT@1:4-1:5 1)) (LVAR@2:0-2:1 :x))
```


## DVAR

ブロック内で定義された変数の参照。

| index | 説明     | Class                            |
|:------|:---------|:---------------------------------|
| 0     | 変数名   | Symbol                           |


## GVAR

グローバル変数を表す。

| index | 説明     | Class                            |
|:------|:---------|:---------------------------------|
| 0     | 変数名   | Symbol                           |


```ruby
$x
```

```
(GVAR@1:0-1:2 :$x)
```


## IVAR

インスタンス変数を表す。

| index | 説明     | Class                            |
|:------|:---------|:---------------------------------|
| 0     | 変数名   | Symbol                           |


```ruby
@x
```

```
(IVAR@1:0-1:2 :@x)
```

## CONST

定数の参照

| index | 説明     | Class                            |
|:------|:---------|:---------------------------------|
| 0     | 定数名   | Symbol                           |

```ruby
X
```

```
(CONST@1:0-1:1 :X)
```

## CVAR

クラス変数を表す

| index | 説明     | Class                            |
|:------|:---------|:---------------------------------|
| 0     | 変数名   | Symbol                           |

```ruby
@@x
```

```
(CVAR@1:0-1:3 :@@x)
```


## NTH_REF

正規表現でマッチした値を取り出す特殊変数 (`$1`, `$2`, ...

| index | 説明     | Class                            |
|:------|:---------|:---------------------------------|
| 0     | 変数名   | Symbol                           |


```ruby
$1
```

```
(NTH_REF@1:0-1:2 :$1)
```

## BACK_REF

正規表現でマッチした値を取り出す特殊変数 (`$&`, `$+`, ...

| index | 説明     | Class                            |
|:------|:---------|:---------------------------------|
| 0     | 変数名   | Symbol                           |


## MATCH

正規表現 (リテラルのみ）

| index | 説明           | Class                            |
|:------|:---------------|:---------------------------------|
| 0     | 正規表現       | RubyVM::AbstractSyntaxTree::Node |


## MATCH2

正規表現 (正規表現が左辺に存在する場合)

| index | 説明           | Class                            |
|:------|:---------------|:---------------------------------|
| 0     | 正規表現       | RubyVM::AbstractSyntaxTree::Node |
| 1     | 文字列         | RubyVM::AbstractSyntaxTree::Node |

```ruby
/foo/ =~ 'foo'
```

```
(MATCH2@1:0-1:14 (LIT@1:0-1:5 /foo/) (STR@1:9-1:14 "foo"))
```


## MATCH3

正規表現 (正規表現が右辺に存在する場合)

| index | 説明           | Class                            |
|:------|:---------------|:---------------------------------|
| 0     | 正規表現       | RubyVM::AbstractSyntaxTree::Node |
| 1     | 文字列         | RubyVM::AbstractSyntaxTree::Node |

```ruby
'foo' =~ /foo/
```

```
(MATCH3@1:0-1:14 (LIT@1:9-1:14 /foo/) (STR@1:0-1:5 "foo"))
```


## LIT

リテラル

| index | 説明           | Class                            |
|:------|:---------------|:---------------------------------|
| 0     | 値             | RubyVM::AbstractSyntaxTree::Node |

## STR

文字列

| index | 説明           | Class  |
|:------|:---------------|:-------|
| 0     | 値             | String |


## DSTR

内部展開のある文字列

| index | 説明                           | Class                                               | 備考                         |
|:------|:-------------------------------|:----------------------------------------------------|:-----------------------------|
| 0     | 内部展開式の前の文字列         | String                                              | 前の要素が無い場合は空文字列 |
| 1     | 内部展開の式                   | RubyVM::AbstractSyntaxTree::Node                    |                              |
| 2     | 内部展開式の後ろの要素のリスト | RubyVM::AbstractSyntaxTree::Node[ARRAY] or NilClass | 後ろの要素が無い場合は `nil` |


## XSTR

外部コマンド実行 (バッククォート形式)

| index | 説明           | Class                            |
|:------|:---------------|:---------------------------------|
| 0     | 値             | RubyVM::AbstractSyntaxTree::Node |


## DXSTR

内部展開のある外部コマンド実行リテラル

| index | 説明                           | Class                                               | 備考                         |
|:------|:-------------------------------|:----------------------------------------------------|:-----------------------------|
| 0     | 内部展開式の前の文字列         | String or NilClass                                  | 前の要素が無い場合は `nil`   |
| 1     | 内部展開の式                   | RubyVM::AbstractSyntaxTree::Node                    |                              |
| 2     | 内部展開式の後ろの要素のリスト | RubyVM::AbstractSyntaxTree::Node[ARRAY] or NilClass | 後ろの要素が無い場合は `nil` |


## EVSTR

内部展開式

| index | 説明 | Class                            |
|:------|:-----|:---------------------------------|
| 0     | 本体 | RubyVM::AbstractSyntaxTree::Node |


## DREGX

内部展開のある正規表現リテラル。

| index | 説明                           | Class                                               | 備考                         |
|:------|:-------------------------------|:----------------------------------------------------|:-----------------------------|
| 0     | 内部展開式の前の文字列         | String                                              | 前の要素が無い場合は空文字列 |
| 1     | 内部展開の式                   | RubyVM::AbstractSyntaxTree::Node                    |                              |
| 2     | 内部展開式の後ろの要素のリスト | RubyVM::AbstractSyntaxTree::Node[ARRAY] or NilClass | 後ろの要素が無い場合は `nil` |


## ONCE

正規表現 ( `o` オプション付き


```ruby
/foo#{bar}baz/o
```

```
(ONCE@1:0-1:15
   (DREGX@1:0-1:15 "foo" (EVSTR@1:4-1:10 (VCALL@1:6-1:9 :bar))
      (ARRAY@1:10-1:13 (STR@1:10-1:13 "baz") nil)))
```


## ARGS

引数の一覧 (TBD)

| index | 説明                     | Class                            |
|:------|:-------------------------|:---------------------------------|
| 0     | 引数の個数               | Integer                          |
| 2     | オプション引数           | RubyVM::AbstractSyntaxTree::Node |
| 6     | 可変長引数               | Symbol                           |
| 7     | キーワード引数           | RubyVM::AbstractSyntaxTree::Node |
| 8     | 可変長キーワード引数     | RubyVM::AbstractSyntaxTree::Node |
| 9     | block 引数の名前         | Symbol                           |


## OPT_ARG

オプション引数

| index | 説明                 | Class                                        |
|:------|:---------------------|:---------------------------------------------|
| 0     | オプション引数の本体 | RubyVM::AbstractSyntaxTree::Node             |
| 1     | 次のオプション引数   | RubyVM::AbstractSyntaxTree::Node or NilClass |


## KW_ARG

キーワード引数

| index | 説明                 | Class                                        |
|:------|:---------------------|:---------------------------------------------|
| 0     | キーワード引数の本体 | RubyVM::AbstractSyntaxTree::Node             |
| 1     | 次のキーワード引数   | RubyVM::AbstractSyntaxTree::Node or NilClass |


## POSTARG

可変長引数の後に引数を定義

| index | 説明                     | Class                            |
|:------|:-------------------------|:---------------------------------|
| 0     | 可変長引数部分           | RubyVM::AbstractSyntaxTree::Node |
| 1     | 可変長引数以降の引数情報 | RubyVM::AbstractSyntaxTree::Node |


## ARGSCAT

TBD

## ARGSPUSH

`splat` 演算子を引数に使う + 1 つの変数

| index | 説明                                 | Class                            |
|:------|:-------------------------------------|:---------------------------------|
| 0     | splat の対象になっているオブジェクト | RubyVM::AbstractSyntaxTree::Node |
| 1     | 残りの引数                           | RubyVM::AbstractSyntaxTree::Node |


## SPLAT

`splat` 演算子を引数に使う

| index | 説明                                 | Class                            |
|:------|:-------------------------------------|:---------------------------------|
| 0     | splat の対象になっているオブジェクト | RubyVM::AbstractSyntaxTree::Node |


## BLOCK_PASS

block 変数の引き渡し

| index | 説明                       | Class                                        |
|:------|:---------------------------|:---------------------------------------------|
| 0     | block 変数以外の変数リスト | RubyVM::AbstractSyntaxTree::Node or NilClass |
| 1     | block 変数本体             | RubyVM::AbstractSyntaxTree::Node             |


## DEFN

メソッドの定義

| index | 説明           | Class                            |
|:------|:---------------|:---------------------------------|
| 0     | メソッド名     | Symbol                           |
| 1     | メソッドの中身 | RubyVM::AbstractSyntaxTree::Node |

## DEFS

シングルトンメソッドの定義

| index | 説明           | Class                            |
|:------|:---------------|:---------------------------------|
| 0     | レシーバー     | RubyVM::AbstractSyntaxTree::Node |
| 1     | メソッド名     | Symbol                           |
| 2     | メソッドの中身 | RubyVM::AbstractSyntaxTree::Node |

## ALIAS

`alias`

| index | 説明       | Class                            |
|:------|:-----------|:---------------------------------|
| 0     | 新しい名前 | RubyVM::AbstractSyntaxTree::Node |
| 1     | 古い名前   | RubyVM::AbstractSyntaxTree::Node |


```ruby
alias foo bar
```

```
(ALIAS@1:0-1:13 (LIT@1:6-1:9 :foo) (LIT@1:10-1:13 :bar))
```


## VALIAS

グローバル変数に対する `alias`

| index | 説明       | Class  |
|:------|:-----------|:-------|
| 0     | 新しい名前 | Symbol |
| 1     | 古い名前   | Symbol |

```ruby
alias $MATCH $&
```

```
(VALIAS@1:0-1:15 :$MATCH :$&)
```


## UNDEF

`undef`

| index | 説明                 | Class                            |
|:------|:---------------------|:---------------------------------|
| 0     | 指定されたメソッド名 | RubyVM::AbstractSyntaxTree::Node |

```ruby
undef foo
```

```
(UNDEF@1:6-1:9 (LIT@1:6-1:9 :foo))
```

## CLASS

クラスの定義

| index | 説明               | Class                                        | 備考                             |
|:------|:-------------------|:---------------------------------------------|:---------------------------------|
| 0     | クラスの名のパス   | RubyVM::AbstractSyntaxTree::Node             |                                  |
| 1     | スーパークラス     | RubyVM::AbstractSyntaxTree::Node or NilClass | クラスを継承していない場合は nil |
| 2     | クラスの中身       | RubyVM::AbstractSyntaxTree::Node             |                                  |

```ruby
class Foo
end
```

```
(CLASS@1:0-2:3 (COLON2@1:6-1:9 nil :Foo) nil
   (SCOPE@1:0-2:3 tbl: [] args: nil body: (BEGIN@1:9-1:9 nil)))
```


## MODULE

モジュールの定義

| index | 説明               | Class                            |
|:------|:-------------------|:---------------------------------|
| 0     | モジュール名のパス | RubyVM::AbstractSyntaxTree::Node |
| 1     | モジュールの本体   | RubyVM::AbstractSyntaxTree::Node |


## SCLASS

シングルトンクラスの定義

| index | 説明               | Class                            |
|:------|:-------------------|:---------------------------------|
| 0     | モジュール名のパス | RubyVM::AbstractSyntaxTree::Node |
| 1     | モジュールの本体   | RubyVM::AbstractSyntaxTree::Node |


## COLON2

名前空間付きの定数定義

| index | 説明               | Class                                        | 備考                           |
|:------|:-------------------|:---------------------------------------------|:-------------------------------|
| 0     | 定数パス           | RubyVM::AbstractSyntaxTree::Node or NilClass | 定数パスが存在しない場合は nil |
| 1     | 定数名             | Symbol                                       |                                |

```ruby
FOO::BAR
```

```
(COLON2@1:0-1:8 (CONST@1:0-1:3 :FOO) :BAR)
```

## COLON3

トップレベルの定数参照

| index | 説明               | Class  |
|:------|:-------------------|:-------|
| 0     | 定数名             | Symbol |


```ruby
::FOO
```

```
(COLON3@1:0-1:5 :FOO)
```


## DOT2

`..`

| index | 説明       | Class                            |
|:------|:-----------|:---------------------------------|
| 0     | 始端の要素 | RubyVM::AbstractSyntaxTree::Node |
| 1     | 終端の要素 | RubyVM::AbstractSyntaxTree::Node |


```ruby
(1..5)
```

```
(DOT2@1:1-1:5 (LIT@1:1-1:2 1) (LIT@1:4-1:5 5))
```

## DOT3

`...`

| index | 説明       | Class                            |
|:------|:-----------|:---------------------------------|
| 0     | 始端の要素 | RubyVM::AbstractSyntaxTree::Node |
| 1     | 終端の要素 | RubyVM::AbstractSyntaxTree::Node |

```ruby
(1...5)
```

```
(DOT3@1:1-1:6 (LIT@1:1-1:2 1) (LIT@1:5-1:6 5))
```

## FLIP2

フリップフロップを表す (`..`)

| index | 説明       | Class                            |
|:------|:-----------|:---------------------------------|
| 0     | 始端の条件 | RubyVM::AbstractSyntaxTree::Node |
| 1     | 終端の条件 | RubyVM::AbstractSyntaxTree::Node |
    
## FLIP3

フリップフロップを表す (`...`)

| index | 説明       | Class                            |
|:------|:-----------|:---------------------------------|
| 0     | 始端の条件 | RubyVM::AbstractSyntaxTree::Node |
| 1     | 終端の条件 | RubyVM::AbstractSyntaxTree::Node |

## SELF

`self` を表す

特になし

## NIL

`nil` を表す

特になし

```ruby
nil
```

```
(NIL@1:0-1:3)
```

## TRUE

`true` を表す

特になし

## FALSE

`false` を表す

特になし

## ERRINFO

TBD

## DEFINED

`defined?` を表す

| index | 説明                     | Class                            |
|:------|:-------------------------|:---------------------------------|
| 0     | 定義の確認の対象となる式 | RubyVM::AbstractSyntaxTree::Node |

## POSTEXE

Ruby のプログラムの終了時に実行する `END` ブロック。

| index | 説明       | Class                            |
|:------|:-----------|:---------------------------------|
| 0     | 処理の本体 | RubyVM::AbstractSyntaxTree::Node |


## DSYM

内部展開のあるシンボル

| index | 説明                     | Class                            |
|:------|:-------------------------|:---------------------------------|
| 0     | 内部展開の式             | RubyVM::AbstractSyntaxTree::Node |
| 1     | 内部展開式の後ろの文字列 | RubyVM::AbstractSyntaxTree::Node |


## ATTRASGN

属性への代入

| index | 説明       | Class                                        |
|:------|:-----------|:---------------------------------------------|
| 0     | レシーバー | RubyVM::AbstractSyntaxTree::Node             |
| 1     | メソッド名 | Symbol                                       |
| 2     | 代入する値 | RubyVM::AbstractSyntaxTree::Node or NilClass |

## LAMBDA

ラムダ記法

| index | 説明         | Class                            |
|:------|:-------------|:---------------------------------|
| 0     | ラムダの本体 | RubyVM::AbstractSyntaxTree::Node |