files.com 1.0.1

data/vendor/bundle/ruby/2.5.0/gems/parser-2.7.1.4/bin/ruby-parse

@@ -0,0 +1,7 @@
+#! /usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+require 'parser/runner/ruby_parse'
+
+Parser::Runner::RubyParse.go(ARGV)

data/vendor/bundle/ruby/2.5.0/gems/parser-2.7.1.4/bin/ruby-rewrite

@@ -0,0 +1,7 @@
+#! /usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+require 'parser/runner/ruby_rewrite'
+
+Parser::Runner::RubyRewrite.go(ARGV)

data/vendor/bundle/ruby/2.5.0/gems/parser-2.7.1.4/ci/run_rubocop_specs

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+
+set -eux
+
+bundle install
+rake generate
+
+git clone https://github.com/rubocop-hq/rubocop.git --depth=1
+cd rubocop
+export BUNDLE_GEMFILE=Gemfile
+echo "gem 'parser', path: '../'" > Gemfile.local
+
+bundle install
+bundle exec rake spec

data/vendor/bundle/ruby/2.5.0/gems/parser-2.7.1.4/doc/AST_FORMAT.md

@@ -0,0 +1,2283 @@
+AST and Source Location
+=======================
+
+## Literals
+
+### Singletons
+
+Format:
+
+~~~
+(true)
+"true"
+ ~~~~ expression
+
+(false)
+"false"
+ ~~~~~ expression
+
+(nil)
+"nil"
+ ~~~ expression
+~~~
+
+### Integer
+
+Format:
+
+~~~
+(int 123)
+"123"
+ ~~~ expression
+
+(int -123)
+"-123"
+ ^ operator
+ ~~~ expression
+
+(int 1)
+"__LINE__"
+ ~~~~~~~~ expression
+~~~
+
+### Float
+
+Format:
+
+~~~
+(float 1.0)
+"1.0"
+ ~~~ expression
+
+(float -1.0)
+"-1.0"
+ ^ operator
+ ~~~~ expression
+~~~
+
+### Complex
+
+Format:
+
+~~~
+(complex (0+1i))
+"1i"
+ ~~ expression
+
+(complex (0+(1/1)*i))
+"1ri"
+ ~~~ expression
+~~~
+
+### Rational
+
+Format:
+
+~~~
+(rational (2/1))
+"2.0r"
+ ~~~~ expression
+~~~
+
+### String
+
+#### Plain
+
+Format:
+
+~~~
+(str "foo")
+"'foo'"
+ ^ begin
+     ^ end
+ ~~~~~ expresion
+
+(string "foo.rb")
+"__FILE__"
+ ~~~~~~~~ expression
+~~~
+
+#### With interpolation
+
+Format:
+
+~~~
+(dstr (str "foo") (begin (lvar bar)) (str "baz"))
+'"foo#{bar}baz"'
+ ^ begin      ^ end
+ ~~~~~~~~~~~~~~ expression
+     ^^ begin (begin)
+          ^ end (begin)
+     ^^^^^^ expression (begin)
+~~~
+
+#### Here document
+
+Format:
+
+~~~
+(str "foo\nbar\n")
+'<<HERE␊foo␊bar␊HERE'
+ ~~~~~~ expression
+        ~~~~~~~~ heredoc_body
+                ~~~~ heredoc_end
+~~~
+
+### Symbol
+
+#### Plain
+
+Format:
+
+~~~
+(sym :foo)
+":foo"
+ ~~~~ expresion
+
+":'foo'"
+  ^ begin
+      ^ end
+ ~~~~~~ expression
+~~~
+
+#### With interpolation
+
+Format:
+
+~~~
+(dsym (str "foo") (lvar bar) (str "baz"))
+':"foo#{bar}baz"'
+  ^ begin      ^ end
+ ~~~~~~~~~~~~~~~ expression
+~~~
+
+### Execute-string
+
+#### Plain
+
+Format:
+
+~~~
+(xstr (str "foo") (lvar bar))
+"`foo#{bar}`"
+ ^ begin   ^ end
+ ~~~~~~~~~~~ expression
+~~~
+
+#### Here document
+
+Format:
+
+~~~
+(xstr (str "foo\nbar\n"))
+"<<`HERE`␊foo␊bar␊HERE"
+ ~~~~~~~~ expression
+          ~~~~~~~~ heredoc_body
+                  ~~~~ heredoc_end
+~~~
+
+### Regexp
+
+#### Options
+
+Format:
+
+~~~
+(regopt :i :m)
+"im"
+ ~~ expression
+~~~
+
+#### Regexp
+
+Format:
+
+~~~
+(regexp (str "foo") (lvar :bar) (regopt :i))
+"/foo#{bar}/i"
+ ^ begin   ^ end
+ ~~~~~~~~~~~ expression
+~~~
+
+### Array
+
+#### Plain
+
+Format:
+
+~~~
+(array (int 1) (int 2))
+
+"[1, 2]"
+ ^ begin
+      ^ end
+ ~~~~~~ expression
+~~~
+
+#### Splat
+
+Can also be used in argument lists: `foo(bar, *baz)`
+
+Format:
+
+~~~
+(splat (lvar :foo))
+"*foo"
+ ^ operator
+ ~~~~ expression
+~~~
+
+#### With interpolation
+
+Format:
+
+~~~
+(array (int 1) (splat (lvar :foo)) (int 2))
+
+"[1, *foo, 2]"
+ ^ begin    ^ end
+ ~~~~~~~~~~~~ expression
+~~~
+
+### Hash
+
+#### Pair
+
+##### With hashrocket
+
+Format:
+
+~~~
+(pair (int 1) (int 2))
+"1 => 2"
+   ~~ operator
+ ~~~~~~ expression
+~~~
+
+##### With label (1.9)
+
+Format:
+
+~~~
+(pair (sym :answer) (int 42))
+"answer: 42"
+       ^ operator (pair)
+ ~~~~~~ expression (sym)
+ ~~~~~~~~~~ expression (pair)
+~~~
+
+#### Plain
+
+Format:
+
+~~~
+(hash (pair (int 1) (int 2)) (pair (int 3) (int 4)))
+"{1 => 2, 3 => 4}"
+ ^ begin        ^ end
+ ~~~~~~~~~~~~~~~~ expression
+~~~
+
+#### Keyword splat (2.0)
+
+Can also be used in argument lists: `foo(bar, **baz)`
+
+Format:
+
+~~~
+(kwsplat (lvar :foo))
+"**foo"
+ ~~ operator
+ ~~~~~ expression
+~~~
+
+#### With interpolation (2.0)
+
+Format:
+
+~~~
+(hash (pair (sym :foo) (int 2)) (kwsplat (lvar :bar)))
+"{ foo: 2, **bar }"
+ ^ begin         ^ end
+ ~~~~~~~~~~~~~~~~~ expression
+~~~
+
+### Range
+
+#### Inclusive
+
+Format:
+
+~~~
+(irange (int 1) (int 2))
+"1..2"
+  ~~ operator
+ ~~~~ expression
+~~~
+
+#### Exclusive
+
+Format:
+
+~~~
+(erange (int 1) (int 2))
+"1...2"
+  ~~~ operator
+ ~~~~~ expression
+~~~
+
+
+### Endless (2.6)
+
+Format:
+
+~~~
+(irange (int 1) nil)
+"1.."
+  ~~ operator
+ ~~~ expression
+
+(erange (int 1) nil)
+"1..."
+  ~~~ operator
+ ~~~~ expression
+~~~
+
+### Beginless (2.7)
+
+Format:
+
+~~~
+(irange nil (int 1))
+"..1"
+ ~~ operator
+ ~~~ expression
+
+(erange nil (int 1))
+"...1"
+ ~~~ operator
+ ~~~~ expression
+~~~
+
+## Access
+
+### Self
+
+Format:
+
+~~~
+(self)
+"self"
+ ~~~~ expression
+~~~
+
+### Local variable
+
+Format:
+
+~~~
+(lvar :foo)
+"foo"
+ ~~~ expression
+~~~
+
+### Instance variable
+
+Format:
+
+~~~
+(ivar :@foo)
+"@foo"
+ ~~~~ expression
+~~~
+
+### Class variable
+
+Format:
+
+~~~
+(cvar :@@foo)
+"@@foo"
+ ~~~~~ expression
+~~~
+
+### Global variable
+
+#### Regular global variable
+
+Format:
+
+~~~
+(gvar :$foo)
+"$foo"
+ ~~~~ expression
+~~~
+
+#### Regular expression capture groups
+
+Format:
+
+~~~
+(nth-ref 1)
+"$1"
+ ~~ expression
+~~~
+
+#### Regular expression back-references
+
+Format:
+
+~~~
+(back-ref :$&)
+"$&"
+ ~~ expression
+(back-ref :$`)
+"$`"
+(back-ref :$')
+"$'"
+(back-ref :$+)
+"$+"
+~~~
+
+### Constant
+
+#### Top-level constant
+
+Format:
+
+~~~
+(const (cbase) :Foo)
+"::Foo"
+   ~~~ name
+ ~~ double_colon
+ ~~~~~ expression
+~~~
+
+#### Scoped constant
+
+Format:
+
+~~~
+(const (lvar :a) :Foo)
+"a::Foo"
+    ~~~ name
+  ~~ double_colon
+ ~~~~~~ expression
+~~~
+
+#### Unscoped constant
+
+Format:
+
+~~~
+(const nil :Foo)
+"Foo"
+ ~~~ name
+ ~~~ expression
+~~~
+
+### defined?
+
+Format:
+
+~~~
+(defined? (lvar :a))
+"defined? a"
+ ~~~~~~~~ keyword
+ ~~~~~~~~~~ expression
+
+"defined?(a)"
+ ~~~~~~~~ keyword
+         ^ begin
+           ^ end
+ ~~~~~~~~~~~ expression
+~~~
+
+## Assignment
+
+### To local variable
+
+Format:
+
+~~~
+(lvasgn :foo (lvar :bar))
+"foo = bar"
+     ^ operator
+ ~~~~~~~~~ expression
+~~~
+
+### To instance variable
+
+Format:
+
+~~~
+(ivasgn :@foo (lvar :bar))
+"@foo = bar"
+      ^ operator
+ ~~~~~~~~~~ expression
+~~~
+
+### To class variable
+
+Format:
+
+~~~
+(cvasgn :@@foo (lvar :bar))
+"@@foo = bar"
+       ^ operator
+ ~~~~~~~~~~~ expression
+~~~
+
+### To global variable
+
+Format:
+
+~~~
+(gvasgn :$foo (lvar :bar))
+"$foo = bar"
+      ^ operator
+ ~~~~~~~~~~ expression
+~~~
+
+### To constant
+
+#### Top-level constant
+
+Format:
+
+~~~
+(casgn (cbase) :Foo (int 1))
+"::Foo = 1"
+   ~~~ name
+       ~ operator
+ ~~~~~~~ expression
+~~~
+
+#### Scoped constant
+
+Format:
+
+~~~
+(casgn (lvar :a) :Foo (int 1))
+"a::Foo = 1"
+    ~~~ name
+        ~ operator
+ ~~~~~~~~ expression
+~~~
+
+#### Unscoped constant
+
+Format:
+
+~~~
+(casgn nil :Foo (int 1))
+"Foo = 1"
+ ~~~ name
+     ~ operator
+ ~~~~~~~ expression
+~~~
+
+### To attribute
+
+Format:
+
+~~~
+(send (self) :foo= (int 1))
+"self.foo = 1"
+     ^ dot
+      ~~~ selector
+          ^ operator
+ ~~~~~~~~~~~~ expression
+~~~
+
+### To attribute, using "safe navigation operator"
+
+Format:
+
+~~~
+(csend (self) :foo= (int 1))
+"self&.foo = 1"
+     ^^ dot
+       ~~~ selector
+           ^ operator
+ ~~~~~~~~~~~~~ expression
+~~~
+
+### Multiple assignment
+
+#### Multiple left hand side
+
+Format:
+
+~~~
+(mlhs (lvasgn :a) (lvasgn :b))
+"a, b"
+ ~~~~ expression
+"(a, b)"
+ ^ begin
+      ^ end
+ ~~~~~~ expression
+~~~
+
+#### Assignment
+
+Rule of thumb: every node inside `(mlhs)` is "incomplete"; to make
+it "complete", one could imagine that a corresponding node from the
+mrhs is "appended" to the node in question. This applies both to
+side-effect free assignments (`lvasgn`, etc) and side-effectful
+assignments (`send`).
+
+Format:
+
+~~~
+(masgn (mlhs (lvasgn :foo) (lvasgn :bar)) (array (int 1) (int 2)))
+"foo, bar = 1, 2"
+          ^ operator
+ ~~~~~~~~~~~~~~~ expression
+
+(masgn (mlhs (ivasgn :@a) (cvasgn :@@b)) (array (splat (lvar :c))))
+"@a, @@b = *c"
+
+(masgn (mlhs (lvasgn :a) (mlhs (lvasgn :b)) (lvasgn :c)) (lvar :d))
+"a, (b, c) = d"
+
+(masgn (mlhs (send (self) :a=) (send (self) :[]= (int 1))) (lvar :a))
+"self.a, self[1] = a"
+~~~
+
+### Binary operator-assignment
+
+Binary operator-assignment features the same "incomplete assignments" and "incomplete calls" as [multiple assignment](#assignment-1).
+
+#### Variable binary operator-assignment
+
+Format:
+
+~~~
+(op-asgn (lvasgn :a) :+ (int 1))
+"a += 1"
+   ~~ operator
+ ~~~~~~ expression
+
+(op-asgn (ivasgn :a) :+ (int 1))
+"@a += 1"
+~~~
+
+#### Method binary operator-assignment
+
+Format:
+
+~~~
+(op-asgn (send (ivar :@a) :b) :+ (int 1))
+"@a.b += 1"
+    ~ selector (send)
+ ~~~~ expression (send)
+      ~~ operator (op-asgn)
+ ~~~~~~~~~ expression (op-asgn)
+
+(op-asgn (send (ivar :@a) :[] (int 0) (int 1))) :+ (int 1))
+"@a[0, 1] += 1"
+   ~~~~~~ selector (send)
+ ~~~~~~~~ expression (send)
+          ~~ operator (op-asgn)
+ ~~~~~~~~~~~~~ expression (op-asgn)
+~~~
+
+### Logical operator-assignment
+
+Logical operator-assignment features the same "incomplete assignments" and "incomplete calls" as [multiple assignment](#assignment-1).
+
+#### Variable logical operator-assignment
+
+Format:
+
+~~~
+(or-asgn (ivasgn :@a) (int 1))
+"@a ||= 1"
+    ~~~ operator
+ ~~~~~~~~ expression
+
+(and-asgn (lvasgn :a) (int 1))
+"a &&= 1"
+   ~~~ operator
+ ~~~~~~~ expression
+~~~
+
+#### Method logical operator-assignment
+
+Format:
+
+~~~
+(or-asgn (send (ivar :@foo) :bar) (int 1))
+"@foo.bar ||= 1"
+      ~~~ selector (send)
+ ~~~~~~~~ expr (send)
+          ~~~ operator (or-asgn)
+ ~~~~~~~~~~~~~~ expression (or-asgn)
+
+(and-asgn (send (lvar :@foo) :bar) (int 1))
+"foo.bar &&= 1"
+     ~~~ selector (send)
+ ~~~~~~~ expr (send)
+         ~~~ operator (and-asgn)
+ ~~~~~~~~~~~~~ expression (and-asgn)
+
+(or-asgn (send (ivar :@foo) :[] (int 1) (int 2)) (int 1))
+"@foo[1, 2] ||= 1"
+     ~~~~~~ selector (send)
+ ~~~~~~~~~~ expr (send)
+            ~~~ operator (or-asgn)
+ ~~~~~~~~~~~~~~~~ expression (or-asgn)
+
+~~~
+
+### Right-hand assignment
+
+Format:
+
+~~~
+(rasgn (int 1) (lvasgn :a))
+"1 => a"
+ ~~~~~~ expression
+   ~~ operator
+~~~
+
+#### Multiple right-hand assignment
+
+Format:
+
+~~~
+(mrasgn (send (int 13) :divmod (int 5)) (mlhs (lvasgn :a) (lvasgn :b)))
+"13.divmod(5) => a,b"
+ ~~~~~~~~~~~~~~~~~~~ expression
+              ^^ operator
+~~~
+
+## Class and module definition
+
+### Module
+
+Format:
+
+~~~
+(module (const nil :Foo) (nil))
+"module Foo; end"
+ ~~~~~~ keyword
+             ~~~ end
+~~~
+
+### Class
+
+Format:
+
+~~~
+(class (const nil :Foo) (const nil :Bar) (nil))
+"class Foo < Bar; end"
+ ~~~~~ keyword    ~~~ end
+           ~ operator
+ ~~~~~~~~~~~~~~~~~~~~ expression
+
+(class (const nil :Foo) nil (nil))
+"class Foo; end"
+ ~~~~~ keyword
+            ~~~ end
+ ~~~~~~~~~~~~~~ expression
+~~~
+
+### Singleton class
+
+Format:
+
+~~~
+(sclass (lvar :a) (nil))
+"class << a; end"
+ ~~~~~ keyword
+       ~~ operator
+             ~~~ end
+ ~~~~~~~~~~~~~~~ expression
+~~~
+
+## Method (un)definition
+
+### Instance methods
+
+Format:
+
+~~~
+(def :foo (args) nil)
+"def foo; end"
+ ~~~ keyword
+     ~~~ name
+          ~~~ end
+ ~~~~~~~~~~~~ expression
+~~~
+
+### Singleton methods
+
+Format:
+
+~~~
+(defs (self) :foo (args) nil)
+"def self.foo; end"
+ ~~~ keyword
+          ~~~ name
+               ~~~ end
+ ~~~~~~~~~~~~~~~~~ expression
+~~~
+
+### "Endless" method
+
+Format:
+
+~~~
+(def_e :foo (args) (int 42))
+"def foo() = 42"
+ ~~~ keyword
+     ~~~ name
+           ^ assignment
+ ~~~~~~~~~~~~~~ expression
+~~~
+
+
+### "Endless" singleton method
+
+Format:
+
+~~~
+(defs_e (self) :foo (args) (int 42))
+"def self.foo() = 42"
+ ~~~ keyword
+          ~~~ name
+                ^ assignment
+ ~~~~~~~~~~~~~~~~~~~ expression
+~~~
+
+### Undefinition
+
+Format:
+
+~~~
+(undef (sym :foo) (sym :bar) (dsym (str "foo") (int 1)))
+"undef foo :bar :"foo#{1}""
+ ~~~~~ keyword
+ ~~~~~~~~~~~~~~~~~~~~~~~~~ expression
+~~~
+
+## Aliasing
+
+### Method aliasing
+
+Format:
+
+~~~
+(alias (sym :foo) (dsym (str "foo") (int 1)))
+"alias foo :"foo#{1}""
+ ~~~~~ keyword
+ ~~~~~~~~~~~~~~~~~~~~ expression
+~~~
+
+### Global variable aliasing
+
+Format:
+
+~~~
+(alias (gvar :$foo) (gvar :$bar))
+"alias $foo $bar"
+ ~~~~~ keyword
+ ~~~~~~~~~~~~~~~ expression
+
+(alias (gvar :$foo) (back-ref :$&))
+"alias $foo $&"
+ ~~~~~ keyword
+ ~~~~~~~~~~~~~~~ expression
+~~~
+
+## Formal arguments
+
+Format:
+
+~~~
+(args (arg :foo))
+"(foo)"
+ ~~~~~ expression
+~~~
+
+### Required argument
+
+Format:
+
+~~~
+(arg :foo)
+"foo"
+ ~~~ expression
+ ~~~ name
+~~~
+
+### Optional argument
+
+Format:
+
+~~~
+(optarg :foo (int 1))
+"foo = 1"
+ ~~~~~~~ expression
+     ^ operator
+ ~~~ name
+~~~
+
+### Named splat argument
+
+Format:
+
+~~~
+(restarg :foo)
+"*foo"
+ ~~~~ expression
+  ~~~ name
+~~~
+
+Begin of the `expression` points to `*`.
+
+### Unnamed splat argument
+
+Format:
+
+~~~
+(restarg)
+"*"
+ ^ expression
+~~~
+
+### Block argument
+
+Format:
+
+~~~
+(blockarg :foo)
+"&foo"
+  ~~~ name
+ ~~~~ expression
+~~~
+
+Begin of the `expression` points to `&`.
+
+### Auto-expanding proc argument (1.9)
+
+In Ruby 1.9 and later, when a proc-like closure (i.e. a closure
+created by capturing a block or with the `proc` method, but not
+with the `->{}` syntax or the `lambda` method) has exactly one
+argument, and it is called with more than one argument, the behavior
+is as if the array of all arguments was instead passed as the sole
+argument. This behavior can be prevented by adding a comma after
+the sole argument (e.g. `|foo,|`).
+
+Format:
+
+~~~
+(procarg0 (arg :foo))
+"|foo|"
+  ~~~ expression
+
+(procarg0 (arg :foo) (arg :bar))
+"|(foo, bar)|"
+  ~ begin
+           ~ end
+  ~~~~~~~~~~ expression
+~~~
+
+### Expression arguments
+
+Ruby 1.8 allows to use arbitrary expressions as block arguments,
+such as `@var` or `foo.bar`. Such expressions should be treated as
+if they were on the lhs of a multiple assignment.
+
+Format:
+
+~~~
+(args (arg_expr (ivasgn :@bar)))
+"|@bar|"
+
+(args (arg_expr (send (send nil :foo) :a=)))
+"|foo.a|"
+
+(args (restarg_expr (ivasgn :@bar)))
+"|*@bar|"
+
+(args (blockarg_expr (ivasgn :@bar)))
+"|&@bar|"
+~~~
+
+### Block shadow arguments
+
+Format:
+
+~~~
+(args (shadowarg :foo) (shadowarg :bar))
+"|; foo, bar|"
+~~~
+
+### Decomposition
+
+Format:
+
+~~~
+(def :f (args (arg :a) (mlhs (arg :foo) (restarg :bar))))
+"def f(a, (foo, *bar)); end"
+          ^ begin   ^ end
+          ~~~~~~~~~~~ expression
+~~~
+
+### Required keyword argument
+
+Format:
+
+~~~
+(kwarg :foo)
+"foo:"
+ ~~~~ expression
+ ~~~~ name
+~~~
+
+### Optional keyword argument
+
+Format:
+
+~~~
+(kwoptarg :foo (int 1))
+"foo: 1"
+ ~~~~~~ expression
+ ~~~~ name
+~~~
+
+### Named keyword splat argument
+
+Format:
+
+~~~
+(kwrestarg :foo)
+"**foo"
+ ~~~~~ expression
+   ~~~ name
+~~~
+
+### Unnamed keyword splat argument
+
+Format:
+
+~~~
+(kwrestarg)
+"**"
+ ~~ expression
+~~~
+
+### Keyword nil argument
+
+Format:
+
+~~~
+(kwnilarg)
+"**nil"
+   ~~~ name
+ ~~~~~ expression
+~~~
+
+### Objective-C arguments
+
+MacRuby includes a few more syntactic "arguments" whose name becomes
+the part of the Objective-C method name, despite looking like Ruby 2.0
+keyword arguments, and are thus treated differently.
+
+#### Objective-C label-like keyword argument
+
+Format:
+
+~~~
+(objc-kwarg :a :b)
+"a: b"
+ ~ keyword
+  ~ operator
+    ~ argument
+ ~~~~ expression
+~~~
+
+#### Objective-C pair-like keyword argument
+
+Format:
+
+~~~
+(objc-kwarg :a :b)
+"a => b"
+ ~ keyword
+   ~~ operator
+      ~ argument
+ ~~~~~~ expression
+~~~
+
+#### Objective-C keyword splat argument
+
+Format:
+
+~~~
+(objc-restarg (objc-kwarg :foo))
+"(*a: b)"
+   ~ objc-kwarg.keyword
+    ~ objc-kwarg.operator
+      ~ objc-kwarg.argument
+  ~ operator
+  ~~~~~ expression
+~~~
+
+Note that these splat arguments will only be parsed inside parentheses,
+e.g. in the following code:
+
+~~~
+def f((*a: b)); end
+~~~
+
+However, the following code results in a parse error:
+
+~~~
+def f(*a: b); end
+~~~
+
+## Numbered parameters
+
+### Block with numbered parameters
+
+Ruby 2.7 introduced a feature called "numbered parameters".
+Numbered and ordinal parameters are mutually exclusive, so if the block
+has only numbered parameters it also has a different AST node.
+
+Note that the second child represents a total number of numbered parameters.
+
+Format:
+
+~~~
+s(:numblock,
+  s(:send, nil, :proc), 3,
+  s(:send,
+    s(:lvar, :_1), :+,
+    s(:lvar, :_3)))
+"proc { _1 + _3 }"
+      ~ begin   ~ end
+ ~~~~~~~~~~~~~~~~ expression
+~~~
+
+## Forward arguments
+
+### Method definition accepting only forwarding arguments
+
+Ruby 2.7 introduced a feature called "arguments forwarding".
+When a method takes any arguments for forwarding them in the future
+the whole `args` node gets replaced with `forward-args` node.
+
+Format if `emit_forward_arg` compatibility flag is disabled:
+
+~~~
+(def :foo
+  (forward-args) nil)
+"def foo(...); end"
+            ~ end
+        ~ begin
+        ~~~~~ expression
+~~~
+
+However, Ruby 2.8 added support for leading arguments before `...`, and so
+it can't be used as a replacement of the `(args)` node anymore. To solve it
+`emit_forward_arg` should be enabled.
+
+Format if `emit_forward_arg` compatibility flag is enabled:
+
+~~~
+(def :foo
+  (args
+    (forward-arg)) nil)
+"def foo(...); end"
+        ~ begin (args)
+            ~ end (args)
+        ~~~~~ expression (args)
+         ~~~ expression (forward_arg)
+~~~
+
+Note that the node is called `forward_arg` when emitted separately.
+
+### Method call taking arguments of the currently forwarding method
+
+Format:
+
+~~~
+(send nil :foo
+  (forwarded-args))
+"foo(...)"
+     ~~~ expression
+~~~
+
+## Send
+
+### To self
+
+Format:
+
+~~~
+(send nil :foo (lvar :bar))
+"foo(bar)"
+ ~~~ selector
+    ^ begin
+        ^ end
+ ~~~~~~~~ expression
+~~~
+
+### To receiver
+
+Format:
+
+~~~
+(send (lvar :foo) :bar (int 1))
+"foo.bar(1)"
+    ^ dot
+     ~~~ selector
+        ^ begin
+          ^ end
+ ~~~~~~~~~~ expression
+
+(send (lvar :foo) :+ (int 1))
+"foo + 1"
+     ^ selector
+ ~~~~~~~ expression
+
+(send (lvar :foo) :-@)
+"-foo"
+ ^ selector
+ ~~~~ expression
+
+(send (lvar :foo) :a= (int 1))
+"foo.a = 1"
+     ~ selector
+       ^ operator
+ ~~~~~~~~~ expression
+~~~
+
+### To superclass
+
+Format of super with arguments:
+
+~~~
+(super (lvar :a))
+"super a"
+ ~~~~~ keyword
+ ~~~~~~~ expression
+
+(super)
+"super()"
+      ^ begin
+       ^ end
+ ~~~~~ keyword
+ ~~~~~~~ expression
+~~~
+
+Format of super without arguments (**z**ero-arity):
+
+~~~
+(zsuper)
+"super"
+ ~~~~~ keyword
+ ~~~~~ expression
+~~~
+
+### To block argument
+
+Format:
+
+~~~
+(yield (lvar :foo))
+"yield(foo)"
+ ~~~~~ keyword
+      ^ begin
+          ^ end
+ ~~~~~~~~~~ expression
+~~~
+
+### Indexing
+
+Format:
+
+~~~
+(index (lvar :foo) (int 1))
+"foo[1]"
+    ^ begin
+      ^ end
+ ~~~~~~ expression
+
+(indexasgn (lvar :bar) (int 1) (int 2) (lvar :baz))
+"bar[1, 2] = baz"
+    ^ begin
+         ^ end
+           ^ operator
+ ~~~~~~~~~~~~~~~ expression
+
+~~~
+
+### Passing a literal block
+
+~~~
+(block (send nil :foo) (args (arg :bar)) (begin ...))
+"foo do |bar|; end"
+     ~~ begin
+               ~~~ end
+     ~~~~~~~~~~~~~ expression
+~~~
+
+### Passing expression as block
+
+Used when passing expression as block `foo(&bar)`
+
+~~~
+(send nil :foo (int 1) (block-pass (lvar :foo)))
+"foo(1, &foo)"
+        ^ operator
+        ~~~~ expression
+~~~
+
+### "Stabby lambda"
+
+~~~
+(block (lambda) (args) nil)
+"-> {}"
+ ~~ lambda.expression
+~~~
+
+### "Safe navigation operator"
+
+~~~
+(csend (send nil :foo) :bar)
+"foo&.bar"
+    ~~ dot
+~~~
+
+### Objective-C variadic send
+
+MacRuby allows to pass a variadic amount of arguments via the last
+keyword "argument". Semantically, these, together with the pair value
+of the last pair in the hash implicitly passed as the last argument,
+form an array, which replaces the pair value. Despite that, the node
+is called `objc-varargs` to distinguish it from a literal array passed
+as a value.
+
+~~~
+(send nil :foo (int 1) (hash (pair (sym :bar) (objc-varargs (int 1) (int 2) (nil)))))
+"foo(1, bar: 2, 3, nil)"
+             ~~~~~~~~~ expression (array)
+~~~
+
+## Control flow
+
+### Logical operators
+
+#### Binary (and or && ||)
+
+Format:
+
+~~~
+(and (lvar :foo) (lvar :bar))
+"foo and bar"
+     ~~~ operator
+ ~~~~~~~~~~~ expression
+~~~
+
+~~~
+(or (lvar :foo) (lvar :bar))
+"foo or bar"
+     ~~ operator
+ ~~~~~~~~~~ expression
+~~~
+
+#### Unary (! not) (1.8)
+
+Format:
+
+~~~
+(not (lvar :foo))
+"!foo"
+ ^ operator
+"not foo"
+ ~~~ operator
+~~~
+
+### Branching
+
+#### Without else
+
+Format:
+
+~~~
+(if (lvar :cond) (lvar :iftrue) nil)
+"if cond then iftrue; end"
+ ~~ keyword
+         ~~~~ begin
+                      ~~~ end
+ ~~~~~~~~~~~~~~~~~~~~~~~~ expression
+
+"if cond; iftrue; end"
+ ~~ keyword
+                  ~~~ end
+ ~~~~~~~~~~~~~~~~~~~~ expression
+
+"iftrue if cond"
+        ~~ keyword
+ ~~~~~~~~~~~~~~ expression
+
+(if (lvar :cond) nil (lvar :iftrue))
+"unless cond then iftrue; end"
+ ~~~~~~ keyword
+             ~~~~ begin
+                          ~~~ end
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression
+
+"unless cond; iftrue; end"
+ ~~~~~~ keyword
+                      ~~~ end
+ ~~~~~~~~~~~~~~~~~~~~~~~~ expression
+
+"iftrue unless cond"
+        ~~~~~~ keyword
+ ~~~~~~~~~~~~~~~~~~ expression
+~~~
+
+#### With else
+
+Format:
+
+~~~
+(if (lvar :cond) (lvar :iftrue) (lvar :iffalse))
+"if cond then iftrue; else; iffalse; end"
+ ~~ keyword
+         ~~~~ begin
+                      ~~~~ else
+                                 ~~~ end
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression
+
+"if cond; iftrue; else; iffalse; end"
+ ~~ keyword
+                  ~~~~ else
+                                 ~~~ end
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression
+
+(if (lvar :cond) (lvar :iffalse) (lvar :iftrue))
+"unless cond then iftrue; else; iffalse; end"
+ ~~~~~~ keyword
+             ~~~~ begin
+                          ~~~~ else
+                                         ~~~ end
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression
+
+"unless cond; iftrue; else; iffalse; end"
+ ~~~~~~ keyword
+                      ~~~~ else
+                                     ~~~ end
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression
+~~~
+
+#### With elsif
+
+Format:
+
+~~~
+(if (lvar :cond1) (int 1) (if (lvar :cond2 (int 2) (int 3))))
+"if cond1; 1; elsif cond2; 2; else 3; end"
+ ~~ keyword (left)
+              ~~~~~ else (left)
+                                      ~~~ end (left)
+              ~~~~~ keyword (right)
+                              ~~~~ else (right)
+                                      ~~~ end (right)
+~~~
+
+#### Ternary
+
+Format:
+
+~~~
+(if (lvar :cond) (lvar :iftrue) (lvar :iffalse))
+"cond ? iftrue : iffalse"
+      ^ question
+               ^ colon
+ ~~~~~~~~~~~~~~~~~~~~~~~ expression
+~~~
+
+### Case matching
+
+#### When clause
+
+Format:
+
+~~~
+(when (regexp "foo" (regopt)) (begin (lvar :bar)))
+"when /foo/ then bar"
+ ~~~~ keyword
+            ~~~~ begin
+ ~~~~~~~~~~~~~~~~~~~ expression
+
+(when (int 1) (int 2) (send nil :meth))
+"when 1, 2; meth"
+
+(when (int 1) (splat (lvar :foo)) (send nil :meth))
+"when 1, *foo; meth"
+
+(when (splat (lvar :foo)) (send nil :meth))
+"when *foo; meth"
+~~~
+
+#### Case-expression clause
+
+##### Without else
+
+Format:
+
+~~~
+(case (lvar :foo) (when (str "bar") (lvar :bar)) nil)
+"case foo; when "bar"; bar; end"
+ ~~~~ keyword               ~~~ end
+~~~
+
+##### With else
+
+Format:
+
+~~~
+(case (lvar :foo) (when (str "bar") (lvar :bar)) (lvar :baz))
+"case foo; when "bar"; bar; else baz; end"
+ ~~~~ keyword               ~~~~ else ~~~ end
+~~~
+
+#### Case-conditions clause
+
+##### Without else
+
+Format:
+
+~~~
+(case nil (when (lvar :bar) (lvar :bar)) nil)
+"case; when bar; bar; end"
+ ~~~~ keyword         ~~~ end
+~~~
+
+##### With else
+
+Format:
+
+~~~
+(case nil (when (lvar :bar) (lvar :bar)) (lvar :baz))
+"case; when bar; bar; else baz; end"
+ ~~~~ keyword         ~~~~ else ~~~ end
+
+(case nil (lvar :baz))
+"case; else baz; end"
+ ~~~~ keyword
+       ~~~~ else
+                 ~~~ end
+~~~
+
+### Looping
+
+#### With precondition
+
+Format:
+
+~~~
+(while (lvar :condition) (send nil :foo))
+"while condition do foo; end"
+ ~~~~~ keyword
+                 ~~ begin
+                         ~~~ end
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression
+
+"while condition; foo; end"
+ ~~~~~ keyword
+                       ~~~ end
+ ~~~~~~~~~~~~~~~~~~~~~~~~~ expression
+
+"foo while condition"
+     ~~~~~ keyword
+ ~~~~~~~~~~~~~~~~~~~ expression
+
+(until (lvar :condition) (send nil :foo))
+"until condition do foo; end"
+ ~~~~~ keyword
+                 ~~ begin
+                         ~~~ end
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression
+
+(until (lvar :condition) (send nil :foo))
+"until condition; foo; end"
+ ~~~~~ keyword
+                       ~~~ end
+~~~~~~~~~~~~~~~~~~~~~~~~~~ expression
+
+"foo until condition"
+     ~~~~~ keyword
+ ~~~~~~~~~~~~~~~~~~~ expression
+~~~
+
+#### With postcondition
+
+Format:
+
+~~~
+(while-post (lvar :condition) (kwbegin (send nil :foo)))
+"begin; foo; end while condition"
+ ~~~~~ begin (begin)
+             ~~~ end (begin)
+                 ~~~~~ keyword (while-post)
+
+(until-post (lvar :condition) (kwbegin (send nil :foo)))
+"begin; foo; end until condition"
+ ~~~~~ begin (begin)
+             ~~~ end (begin)
+                 ~~~~~ keyword (until-post)
+~~~
+
+#### For-in
+
+Format:
+
+~~~
+(for (lvasgn :a) (lvar :array) (send nil :p (lvar :a)))
+"for a in array do p a; end"
+ ~~~ keyword
+       ~~ in
+                ~~ begin
+                        ~~~ end
+
+"for a in array; p a; end"
+ ~~~ keyword
+       ~~ in
+                      ~~~ end
+
+(for
+  (mlhs (lvasgn :a) (lvasgn :b)) (lvar :array)
+  (send nil :p (lvar :a) (lvar :b)))
+"for a, b in array; p a, b; end"
+~~~
+
+#### Break
+
+Format:
+
+~~~
+(break (int 1))
+"break 1"
+ ~~~~~ keyword
+ ~~~~~~~ expression
+~~~
+
+#### Next
+
+Format:
+
+~~~
+(next (int 1))
+"next 1"
+ ~~~~ keyword
+ ~~~~~~ expression
+~~~
+
+#### Redo
+
+Format:
+
+~~~
+(redo)
+"redo"
+ ~~~~ keyword
+ ~~~~ expression
+~~~
+
+### Return
+
+Format:
+
+~~~
+(return (lvar :foo))
+"return(foo)"
+ ~~~~~~ keyword
+ ~~~~~~~~~~~ expression
+~~~
+
+### Exception handling
+
+#### Rescue body
+
+Format:
+
+~~~
+(resbody (array (const nil :Exception) (const nil :A)) (lvasgn :bar) (int 1))
+"rescue Exception, A => bar; 1"
+ ~~~~~~ keyword      ~~ assoc
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression
+
+"rescue Exception, A => bar then 1"
+ ~~~~~~ keyword      ~~ assoc
+                            ~~~~ begin
+
+(resbody (array (const nil :Exception)) (ivasgn :bar) (int 1))
+"rescue Exception => @bar; 1"
+ ~~~~~~ keyword   ~~ assoc
+
+(resbody nil (lvasgn :bar) (int 1))
+"rescue => bar; 1"
+ ~~~~~~ keyword
+        ~~ assoc
+
+(resbody nil nil (int 1))
+"rescue; 1"
+ ~~~~~~ keyword
+~~~
+
+#### Rescue statement
+
+##### Without else
+
+Format:
+
+~~~
+(begin
+  (rescue (send nil :foo) (resbody ...) (resbody ...) nil))
+"begin; foo; rescue Exception; rescue; end"
+ ~~~~~ begin                           ~~~ end
+             ~~~~~~~~~~~~~~~~~ expression (rescue.resbody/1)
+                               ~~~~~~~ expression (rescue.resbody/2)
+        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression (rescue)
+~~~
+
+##### With else
+
+Format:
+
+~~~
+(begin
+  (rescue (send nil :foo) (resbody ...) (resbody ...) (true)))
+"begin; foo; rescue Exception; rescue; else true end"
+ ~~~~~ begin                           ~~~~ else (rescue)
+                                                 ~~~ end
+~~~
+
+#### Ensure statement
+
+Format:
+
+~~~
+(begin
+  (ensure (send nil :foo) (send nil :bar))
+"begin; foo; ensure; bar; end"
+ ~~~~~ begin ~~~~~~ keyword (ensure)
+                          ~~~ end
+~~~
+
+#### Rescue with ensure
+
+Format:
+
+~~~
+(begin
+  (ensure
+    (rescue (send nil :foo) (resbody ...) (int 1))
+    (send nil :bar))
+"begin; foo; rescue; nil; else; 1; ensure; bar; end"
+ ~~~~~ begin
+                          ~~~~ else (ensure.rescue)
+             ~~~~~~~~~~~~~~~~~~~~~ expression (rescue)
+                                   ~~~~~~ keyword (ensure)
+             ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression (ensure)
+                                                ~~~ end
+~~~
+
+#### Retry
+
+Format:
+
+~~~
+(retry)
+"retry"
+ ~~~~~ keyword
+ ~~~~~ expression
+~~~
+
+### BEGIN and END
+
+Format:
+
+~~~
+(preexe (send nil :puts (str "foo")))
+"BEGIN { puts "foo" }"
+ ~~~~~ keyword
+       ^ begin      ^ end
+ ~~~~~~~~~~~~~~~~~~~~ expression
+
+(postexe (send nil :puts (str "bar")))
+"END { puts "bar" }"
+ ~~~ keyword
+     ^ begin      ^ end
+ ~~~~~~~~~~~~~~~~~~ expression
+~~~
+
+## Miscellanea
+
+### Flip-flops
+
+Format:
+
+~~~
+(iflipflop (lvar :a) (lvar :b))
+"if a..b; end"
+     ~~ operator
+    ~~~~ expression
+
+(eflipflop (lvar :a) (lvar :b))
+"if a...b; end"
+     ~~~ operator
+    ~~~~~ expression
+~~~
+
+### Implicit matches
+
+Format:
+
+~~~
+(match-current-line (regexp (str "a") (regopt)))
+"if /a/; end"
+    ~~~ expression
+~~~
+
+### Local variable injecting matches
+
+Format:
+
+~~~
+(match-with-lvasgn (regexp (str "(?<match>bar)") (regopt)) (lvar :baz))
+"/(?<match>bar)/ =~ baz"
+                 ~~ selector
+ ~~~~~~~~~~~~~~~~~~~~~~ expression
+~~~
+
+## Special constants
+
+### File
+
+Format:
+
+~~~
+(__FILE__)
+"__FILE__"
+ ~~~~~~~~ expression
+~~~
+
+### Line
+
+Format:
+
+~~~
+(__LINE__)
+"__LINE__"
+ ~~~~~~~~ expression
+~~~
+
+### Encoding
+
+Format:
+
+~~~
+(__ENCODING__)
+"__ENCODING__"
+ ~~~~~~~~~~~~ expression
+~~~
+
+## Pattern matching
+
+### Using `in` modifier
+
+Format:
+
+~~~
+(in-match
+  (int 1)
+  (match-var :a))
+"1 in a"
+   ~~ operator
+ ~~~~~~ expression
+~~~
+
+### Case with pattern matching
+
+#### Without else
+
+Format:
+
+~~~
+(case-match
+  (str "str")
+  (in-pattern
+    (match-var :foo)
+    (lvar :bar)) nil)
+"case "str"; in foo; bar; end"
+ ~~~~ keyword             ~~~ end
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression
+~~~
+
+#### With else
+
+Format:
+
+~~~
+(case-match,
+  (str "str")
+  (in-pattern
+    (match-var :foo)
+    (lvar :bar))
+  (lvar :baz))
+"case "str"; in foo; bar; else; baz; end"
+ ~~~~ keyword             ~~~~ else  ~~~ end
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression
+~~~
+
+#### With empty else
+
+Empty `else` differs from the missing (or _implicit_) `else` for pattern matching, since
+the latter one raises a `NoMatchingPattern` exception. Thus, we need a way to distinguish this
+two cases in the resulting AST.
+
+Format:
+
+~~~
+(case-match,
+  (str "str")
+  (in-pattern
+    (match-var :foo)
+    (lvar :bar))
+  (empty-else))
+"case "str"; in foo; bar; else; end"
+ ~~~~ keyword             ~~~~ else
+                                ~~~ end
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ expression
+~~~
+
+### In clause
+
+Format:
+
+~~~
+(in-pattern
+  (match-var :foo)
+  (lvar :bar))
+"in foo then bar"
+ ~~ keyword
+        ~~~~ begin
+ ~~~~~~~~~~~~~~~ expression
+~~~
+
+### If guard
+
+This guard runs after matching, so it's not an `if` modifier.
+
+Format:
+
+~~~
+(in-pattern
+  (match-var :foo)
+  (if-guard
+    (lvar :bar)) nil)
+"in foo if bar"
+        ~~ keyword
+        ~~~~~~ expression
+~~~
+
+### Unless guard
+
+This guard runs after matching, so it's not an `unless` modifier.
+
+Format:
+
+~~~
+(in-pattern
+  (match-var :foo)
+  (unless-guard
+    (lvar :bar)) nil)
+"in foo unless bar"
+        ~~~~~~ keyword
+        ~~~~~~~~~~ expression
+~~~
+
+### Match variable
+
+Format:
+
+~~~
+(match-var :foo)
+"in foo"
+    ~~~ name
+    ~~~ expression
+~~~
+
+### Match rest
+
+#### With name
+
+Format:
+
+~~~
+(match-rest
+  (match-var :foo))
+"in *foo"
+    ~ operator
+    ~~~~ expression
+~~~
+
+#### Without name
+
+Format:
+
+~~~
+(match-rest)
+"in *"
+    ~ operator
+    ~ expression
+~~~
+
+### Pin operator
+
+Format:
+
+~~~
+(pin
+  (lvar :foo))
+"in ^foo"
+    ~ selector
+    ~~~~ expression
+~~~
+
+### Match alternative
+
+Format:
+
+~~~
+(match-alt
+  (pin
+    (lvar :foo))
+  (int 1))
+"in ^foo | 1"
+         ~ operator
+    ~~~~~~~~ expression
+~~~
+
+### Match with alias
+
+Format:
+
+~~~
+(match-as
+  (int 1)
+  (match-var :foo))
+"in 1 => foo"
+      ~~ operator
+    ~~~~~~~~ expression
+~~~
+
+### Match using array pattern
+
+#### Explicit
+
+Format:
+
+~~~
+(array-pattern
+  (pin
+    (lvar :foo))
+  (match-var :bar))
+"in [^foo, bar]"
+    ~ begin   ~ end
+    ~~~~~~~~~~~ expression
+~~~
+
+#### Explicit with tail
+
+Adding a trailing comma in the end works as `, *`
+
+Format:
+
+~~~
+(array-pattern-with-tail
+  (pin
+    (lvar :foo))
+  (match-var :bar))
+"in [^foo, bar,]"
+    ~ begin    ~ end
+    ~~~~~~~~~~~~ expression
+~~~
+
+#### Implicit
+
+Format:
+
+~~~
+(array-pattern
+  (pin
+    (lvar :foo))
+  (match-var :bar))
+"in ^foo, bar"
+    ~~~~~~~~~ expression
+~~~
+
+#### Implicit with tail
+
+Format:
+
+Adding a trailing comma in the end works as `, *`,
+so a single item match with comma gets interpreted as an array.
+
+~~~
+(array-pattern-with-tail
+  (match-var :foo))
+"in foo,"
+    ~~~~ expression
+~~~
+
+### Matching using hash pattern
+
+#### Explicit
+
+Format:
+
+~~~
+(hash-pattern
+  (pair
+    (sym :a)
+    (int 10)))
+"in { a: 10 }"
+    ~ begin ~ end
+    ~~~~~~~~~ expression
+~~~
+
+#### Implicit
+
+Format:
+
+~~~
+(hash-pattern
+  (pair
+    (sym :a)
+    (int 10)))
+"in a: 10"
+    ~~~~~ expression
+~~~
+
+#### Assignment using hash pattern
+
+Format:
+
+~~~
+(hash-pattern
+  (match-var :a))
+"in a:"
+    ~ name (match-var)
+    ~~ expression (match-var)
+~~~
+
+#### Nil hash pattern
+
+Format:
+~~~
+(hash-pattern
+  (match-nil-pattern))
+"in **nil"
+    ~~~~~ expression (match-nil-pattern)
+      ~~~ name (match-nil-pattern)
+~~~
+
+### Matching using find pattern
+
+Format:
+
+~~~
+(find-pattern
+  (match-rest
+    (match-var :a))
+  (int 42)
+  (match-rest))
+"in [*, 42, *]"
+    ~ begin
+             ~ end
+    ~~~~~~~~~~ expression
+~~~
+
+Note that it can be used as a top-level pattern only when used in a `case` statement. In that case `begin` and `end` are empty.
+
+### Matching using const pattern
+
+#### With array pattern
+
+Format:
+
+~~~
+(const-pattern
+  (const nil :X)
+  (array-pattern
+    (pin
+      (lvar :foo))
+    (match-var :bar)))
+"in X[^foo bar]"
+     ~ begin (const-pattern)
+               ~ end (const-pattern)
+    ~~~~~~~~~~~~ expression (const-pattern)
+    ~ name (const-pattern.const)
+    ~ expression (const-pattern.const)
+~~~
+
+#### With hash pattern
+
+Format:
+
+~~~
+(const-pattern
+  (const nil :X)
+  (hash-pattern
+    (match-var :foo)
+    (match-var :bar)))
+"in X[foo:, bar:]"
+     ~ begin (const-pattern)
+                ~ end (const-pattern)
+    ~~~~~~~~~~~~~ expression (const-pattern)
+    ~ name (const-pattern.const)
+    ~ expression (const-pattern.const)
+~~~
+
+#### With array pattern without elements
+
+Format:
+
+~~~
+(const-pattern
+  (const nil :X)
+  (array-pattern))
+"in X[]"
+     ~ begin (const-pattern)
+      ~ end (const-pattern)
+    ~~~ expression (const-pattern)
+    ~ name (const-pattern.const)
+    ~ expression (const-pattern.const)
+     ~~ expression (const-pattern.array_pattern)
+~~~
+
+#### With find pattern
+
+Format:
+
+~~~
+(const-pattern
+  (const nil :X)
+  (find-pattern
+    (match-rest)
+    (int 42)
+    (match-rest)))
+"in X[*, 42, *]"
+     ~ begin
+              ~ end
+    ~~~~~~~~~~~ expression
+~~~