lib-ruby-parser 4.0.3.0-arm64-darwin

data/lib/lib-ruby-parser/nodes.rb

@@ -0,0 +1,4452 @@
+# This file is autogenerated by codegen/nodes.rb.liquid
+
+# Root module
+module LibRubyParser
+  # Module with all known Node sub-types
+  module Nodes
+    # Represents `alias to from` statement.
+    class Alias < Node
+      # Target of the `alias`.
+      #
+      # `Sym("foo")` node for `alias :foo :bar`
+      #
+      # @return [Node]
+      attr_reader :to
+      # Source of the `alias`.
+      #
+      # `Sym("bar")` node for `alias :foo :bar`
+      #
+      # @return [Node]
+      attr_reader :from
+      # Location of the `alias` keyword
+      #
+      # ```text
+      # alias foo bar
+      # ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the full expression
+      #
+      # ```text
+      # alias foo bar
+      # ~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents `foo && bar` (or `foo and bar`) statement.
+    class And < Node
+      # Left hand statament of the `&&` operation.
+      #
+      # `Lvar("foo")` node for `foo && bar`
+      #
+      # @return [Node]
+      attr_reader :lhs
+      # Right hand statement of the `&&` operation.
+      #
+      # `Lvar("bar")` node for `foo && bar`
+      #
+      # @return [Node]
+      attr_reader :rhs
+      # Location of the `&&` (or `and`) operator
+      #
+      # ```text
+      # a && b
+      #   ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # a && b
+      # ~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents `a &&= 1` statement.
+    class AndAsgn < Node
+      # Receiver of the `&&=` operation.
+      #
+      # `Lvasgn("a")` node for `a &&= 1`
+      #
+      # @return [Node]
+      attr_reader :recv
+      # Right hand statement of assignment
+      #
+      # `Int("1")` node for `a &&= 1`
+      #
+      # @return [Node]
+      attr_reader :value
+      # Location of the `&&=` operator
+      #
+      # ```text
+      # a &&= 1
+      #   ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # a &&= 1
+      # ~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a positional required block/method argument.
+    #
+    # `a` in `def m(a); end` or `proc { |a| }`
+    class Arg < Node
+      # Name of the argument
+      #
+      # @return [String]
+      attr_reader :name
+      # Location of the full expression
+      #
+      # ```text
+      # def m(argument); end
+      #       ~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents an arguments list
+    #
+    # `Args(vec![Arg("a"), Optarg("b", Int("1"))])` in `def m(a, b = 1); end`
+    class Args < Node
+      # List of arguments
+      #
+      # @return [::Array<Node>]
+      attr_reader :args
+      # Location of the full expression
+      #
+      # ```text
+      # def m(a, b = 1, c:, &blk); end
+      #      ~~~~~~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+      # Location of the open parenthesis
+      #
+      # ```text
+      # def m(a, b = 1, c:, &blk); end
+      #      ~
+      # ```
+      #
+      # `None` for code like `def m; end` or `def m arg; end`
+      #
+      # @return [Loc, nil]
+      attr_reader :begin_l
+      # Location of the closing parenthesis
+      #
+      # ```text
+      # def m(a, b = 1, c:, &blk); end
+      #                         ~
+      # ```
+      #
+      # `None` for code like `def m; end` or `def m arg; end`
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+    end
+
+    # Represents an array literal
+    class Array < Node
+      # A list of elements
+      #
+      # @return [::Array<Node>]
+      attr_reader :elements
+      # Location of the open bracket
+      #
+      # ```text
+      # [1, 2, 3]
+      # ~
+      # ```
+      #
+      # @return [Loc, nil]
+      attr_reader :begin_l
+      # Location of the closing bracket
+      #
+      # ```text
+      # [1, 2, 3]
+      #         ~
+      # ```
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # [1, 2, 3]
+      # ~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents an array pattern used in pattern matching
+    class ArrayPattern < Node
+      # A list of elements
+      #
+      # @return [::Array<Node>]
+      attr_reader :elements
+      # Location of the open bracket
+      #
+      # ```text
+      # [1, ^a, 3 => foo]
+      # ~
+      # ```
+      #
+      # `None` for pattern like `1, 2` without brackets
+      #
+      # @return [Loc, nil]
+      attr_reader :begin_l
+      # Location of the closing bracket
+      #
+      # ```text
+      # [1, ^a, 3 => foo]
+      #                 ~
+      # ```
+      #
+      # `None` for pattern like `1, 2` without brackets
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # [1, ^a, 3 => foo]
+      # ~~~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents an array pattern *with trailing comma* used in pattern matching
+    #
+    # It's slightly different from `ArrayPattern`, trailing comma at the end works as `, *`
+    class ArrayPatternWithTail < Node
+      # A list of elements
+      #
+      # @return [::Array<Node>]
+      attr_reader :elements
+      # Location of the open bracket
+      #
+      # ```text
+      # [1, ^a, 3 => foo,]
+      # ~
+      # ```
+      #
+      # `None` for pattern like `1, 2,` without brackets
+      #
+      # @return [Loc, nil]
+      attr_reader :begin_l
+      # Location of the closing bracket
+      #
+      # ```text
+      # [1, ^a, 3 => foo,]
+      #                  ~
+      # ```
+      #
+      # `None` for pattern like `1, 2,` without brackets
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # [1, ^a, 3 => foo,]
+      # ~~~~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents special global variables:
+    # 1. `` $` ``
+    # 2. `$&`
+    # 3. `$'`
+    # 4. `$+`
+    class BackRef < Node
+      # Name of the variable (`"$+"` for `$+`)
+      #
+      # @return [String]
+      attr_reader :name
+      # Location of the full expression
+      #
+      # ```text
+      # $+
+      # ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents compound statement (i.e. a multi-statement)
+    #
+    # Basically all blocks of code are wrapped into `Begin` node (e.g. method/block body, rescue/ensure handler etc)
+    class Begin < Node
+      # A list of statements
+      #
+      # @return [::Array<Node>]
+      attr_reader :statements
+      # Begin of the block
+      #
+      # ```text
+      # (1; 2)
+      # ~
+      # ```
+      #
+      # `None` if the block of code is "implicit", like
+      #
+      # ```text
+      # if true; 1; 2; end
+      # ```
+      #
+      # @return [Loc, nil]
+      attr_reader :begin_l
+      # End of the block
+      #
+      # ```text
+      # (1; 2)
+      #      ~
+      # ```
+      #
+      # `None` if the block of code is "implicit", like
+      #
+      # ```text
+      # if true; 1; 2; end
+      # ```
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # (1; 2)
+      # ~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a Ruby block that is passed to a method (`proc { |foo| bar }`)
+    class Block < Node
+      # Method call that takes a block
+      #
+      # `Send("foo")` in `foo {}`
+      #
+      # @return [Node]
+      attr_reader :call
+      # A list of argument that block takes
+      #
+      # `vec![ Arg("a"), Optarg("b", Int("1")) ]` for `proc { |a, b = 1| }`
+      #
+      # `None` if the block takes no arguments
+      #
+      # @return [Node, nil]
+      attr_reader :args
+      # Block body, `None` if block has no body.
+      #
+      # @return [Node, nil]
+      attr_reader :body
+      # Location of the open brace
+      #
+      # ```text
+      # proc { }
+      #      ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :begin_l
+      # Location of the closing brace
+      #
+      # ```text
+      # proc { }
+      #        ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # proc { }
+      # ~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a `&blk` argument in the method definition (but not in the method call, see `BlockPass`)
+    class Blockarg < Node
+      # Name of the argument, `String("foo")` for `def m(&foo)`
+      #
+      # @return [String, nil]
+      attr_reader :name
+      # Location of the `&` operator
+      #
+      # ```text
+      # def m(&foo); end
+      #       ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the name
+      #
+      # ```text
+      # def m(&foo); end
+      #        ~~~
+      # ```
+      #
+      # @return [Loc, nil]
+      attr_reader :name_l
+      # Location of the full expression
+      #
+      # ```text
+      # def m(&foo); end
+      #       ~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a `&blk` argument of the method call (but not of the method definition, see `BlockArg`)
+    class BlockPass < Node
+      # Value that is converted to a block
+      #
+      # `Int("1")` in `foo(&1)` (yes, it's possible)
+      #
+      # @return [Node, nil]
+      attr_reader :value
+      # Location of the `&` operator
+      #
+      # ```text
+      # foo(&blk)
+      #     ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # foo(&bar)
+      #     ~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a `break` keyword (with optional argument)
+    class Break < Node
+      # A list of arguments
+      #
+      # @return [::Array<Node>]
+      attr_reader :args
+      # Location of the `break` keyword
+      #
+      # ```text
+      # break :foo
+      # ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the full expression
+      #
+      # ```text
+      # break(:foo)
+      # ~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a `case` statement (for pattern matching see `CaseMatch` node)
+    class Case < Node
+      # Expression given to `case`, `Int("1")` for `case 1; end`
+      # `None` for code like
+      #
+      # ```text
+      # case
+      # when pattern
+      # end
+      # ```
+      #
+      # @return [Node, nil]
+      attr_reader :expr
+      # A list of `When` nodes (each has `patterns` and `body`)
+      #
+      # @return [::Array<Node>]
+      attr_reader :when_bodies
+      # Body of the `else` branch, `None` if there's no `else` branch
+      #
+      # @return [Node, nil]
+      attr_reader :else_body
+      # Location of the `case` keyword
+      #
+      # ```text
+      # case 1; end
+      # ~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the `else` keyword
+      #
+      # ```text
+      # case 1; else; end
+      #         ~~~~
+      # ```
+      #
+      # `None` if there's no `else` branch
+      #
+      # @return [Loc, nil]
+      attr_reader :else_l
+      # Location of the `end` keyword
+      #
+      # ```text
+      # case 1; end
+      #         ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # case 1; end
+      # ~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a `case` statement used for pattern matching (for regular `case` see `Case` node)
+    class CaseMatch < Node
+      # Expression given to `case`, `Int("1")` for `case 1; in 1; end`
+      # `None` for code like
+      #
+      # ```text
+      # case
+      # in pattern
+      # end
+      # ```
+      #
+      # @return [Node]
+      attr_reader :expr
+      # A list of `InPattern` nodes (each has `pattern`, `guard` and `body`)
+      #
+      # @return [::Array<Node>]
+      attr_reader :in_bodies
+      # Body of the `else` branch, `None` if there's no `else` branch
+      #
+      # @return [Node, nil]
+      attr_reader :else_body
+      # Location of the `case` keyword
+      #
+      # ```text
+      # case 1; in 2; end
+      # ~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the `else` keyword
+      #
+      # ```text
+      # case 1; in 2; else; end
+      #               ~~~~
+      # ```
+      #
+      # `None` if there's no `else` branch
+      #
+      # @return [Loc, nil]
+      attr_reader :else_l
+      # Location of the `end` keyword
+      #
+      # ```text
+      # case 1; in 2; end
+      #               ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # case 1; in 2; end
+      # ~~~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a constant assignment (i.e. `A = 1`)
+    class Casgn < Node
+      # Scope where the constant is defined:
+      # 1. `Some(Const("A"))` for `A::B = 1`
+      # 2. `None` if it's defined in the current scope (i.e. `A = 1`)
+      # 3. `Some(Cbase)` if it's defined in the global scope (i.e. `::A = 1`)
+      #
+      # @return [Node, nil]
+      attr_reader :scope
+      # Name of the constant, `String("A")` for `A = 1`
+      #
+      # @return [String]
+      attr_reader :name
+      # Value that is assigned to a constant, `Int("1")` for `A = 1`.
+      #
+      # **Note**: `None` if constant assignment is a part of the multi-assignment.
+      # In such case `value` belongs to `Masgn` node of the multi-assignment.
+      #
+      # @return [Node, nil]
+      attr_reader :value
+      # Location of the `::` operator
+      #
+      # ```text
+      # A::B = 1
+      #  ~~
+      #
+      # ::A = 1
+      # ~~
+      # ```
+      #
+      # `None` if the constant is defined in the current scope
+      #
+      # @return [Loc, nil]
+      attr_reader :double_colon_l
+      # Location of the constant name
+      #
+      # ```text
+      # A::CONST = 1
+      #    ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :name_l
+      # Location of the `=` operator
+      #
+      # ```text
+      # A = 1
+      #   ~
+      # ```
+      #
+      # `None` if constant assignment is a part of the multi-assignment.
+      # In such case `=` belongs to a `Masgn` node
+      #
+      # @return [Loc, nil]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # A = 1
+      # ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents leading `::` part of the constant access/assignment that is used to get/set on a global namespace.
+    class Cbase < Node
+      # Location of the full expression
+      #
+      # ```text
+      # ::A
+      # ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a class definition (using a `class` keyword, `Class.new` is just a method call)
+    class Class < Node
+      # Name of the class, `String("Foo")` for `class Foo; end`
+      #
+      # @return [Node]
+      attr_reader :name
+      # Superclass. Can be an expression in cases like `class A < (obj.foo + 1); end`
+      #
+      # `None` if no explicit superclass given (i.e. `class Foo; end`)
+      #
+      # @return [Node, nil]
+      attr_reader :superclass
+      # Body of the method, `None` if there's no body.
+      #
+      # @return [Node, nil]
+      attr_reader :body
+      # Location of the `class` keyword.
+      #
+      # ```text
+      # class Foo; end
+      # ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the `<` operator
+      #
+      # ```text
+      # class A < B; end
+      #         ~
+      # ```
+      #
+      # `None` if there's no explicit superclass given.
+      #
+      # @return [Loc, nil]
+      attr_reader :operator_l
+      # Location of the `end` keyword.
+      #
+      # ```text
+      # class Foo; end
+      #            ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # class Foo; end
+      # ~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a `Complex` literal (that returns an `Complex` number)
+    class Complex < Node
+      # Value of the complex literal, returned as a `String`, `String("1i")` for `1i`
+      #
+      # @return [String]
+      attr_reader :value
+      # Location of the `-` (but not `+`) operator. `+` is a part of the literal:
+      # 1. `+1i` is `String("+1i")` with `operator = None`
+      # 2. `-1i` is `String("1i")` with `operator = String("-")`
+      #
+      # ```text
+      # -1i
+      # ~
+      # ```
+      #
+      # @return [Loc, nil]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # -1i
+      # ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents constant access (i.e. `Foo::Bar`)
+    class Const < Node
+      # Scope where the constant is taken from:
+      # 1. `Some(Const("A"))` for `A::B`
+      # 2. `None` if it's taken from the current scope (i.e. `A`)
+      # 3. `Some(Cbase)` if it's taken from the global scope (i.e. `::A`)
+      #
+      # @return [Node, nil]
+      attr_reader :scope
+      # Name of the constant, `String("Foo")` for `Foo`
+      #
+      # @return [String]
+      attr_reader :name
+      # Location of the `::` operator. `None` if constant is taken from the current scope.
+      #
+      # ```text
+      # A::B
+      #  ~~
+      # ```
+      #
+      # @return [Loc, nil]
+      attr_reader :double_colon_l
+      # Location of the constant name
+      #
+      # ```text
+      # Foo::Bar
+      #      ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :name_l
+      # Location of the full expression
+      #
+      # ```text
+      # Foo::Bar
+      # ~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Const pattern used in pattern matching (e.g. `in A(1, 2)`)
+    class ConstPattern < Node
+      # Constant that is used, `Const("Foo")` for `in For(42)`
+      #
+      # @return [Node]
+      attr_reader :const
+      # Inner part of the constant pattern
+      #
+      # `ArrayPattern(vec![ Int("1") ])` for `Foo(1)`
+      #
+      # @return [Node]
+      attr_reader :pattern
+      # Location of the open parenthesis
+      #
+      # ```text
+      # case 1; in Foo(42); end
+      #               ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :begin_l
+      # Location of the closing parenthesis
+      #
+      # ```text
+      # case 1; in Foo(42); end
+      #                  ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # case 1; in Foo(42); end
+      #            ~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents conditional method call using `&.` operator
+    class CSend < Node
+      # Receiver of the method call, `Int("1")` for `1&.foo`
+      #
+      # @return [Node]
+      attr_reader :recv
+      # Name of the method, `String("foo")` for `1&.foo`
+      #
+      # @return [String]
+      attr_reader :method_name
+      # List of arguments
+      #
+      # ```text
+      # foo&.bar(42)
+      # # and also setters like
+      # foo&.bar = 42
+      # ```
+      #
+      # @return [::Array<Node>]
+      attr_reader :args
+      # Location of the `&.` operator
+      #
+      # ```text
+      # foo&.bar
+      #    ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :dot_l
+      # Location of the method name
+      #
+      # ```text
+      # foo&.bar(42)
+      #      ~~~
+      # ```
+      #
+      # `None` in a very special case when method call is implicit (i.e. `foo&.()`)
+      #
+      # @return [Loc, nil]
+      attr_reader :selector_l
+      # Location of the open parenthesis
+      #
+      # ```text
+      # foo&.bar(42)
+      #         ~
+      # ```
+      #
+      # `None` if there are no parentheses
+      #
+      # @return [Loc, nil]
+      attr_reader :begin_l
+      # Location of the closing parenthesis
+      #
+      # ```text
+      # foo&.bar(42)
+      #            ~
+      # ```
+      #
+      # `None` if there are no parentheses
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the operator if `CSend` is a part of assignment like
+      #
+      # ```text
+      # foo&.bar = 1
+      #          ~
+      # ```
+      #
+      # `None` for a regular call.
+      #
+      # @return [Loc, nil]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # foo&.bar(42)
+      # ~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents access to class variable (i.e. `@@var`)
+    class Cvar < Node
+      # Name of the class variable, `String("@@foo")` for `@@foo`
+      #
+      # @return [String]
+      attr_reader :name
+      # Location of the full expression
+      #
+      # ```text
+      # @@foo
+      # ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents class variable assignment (i.e. `@@var = 42`)
+    class Cvasgn < Node
+      # Name of the class variable, `String("@@foo")` for `@@foo = 1`
+      #
+      # @return [String]
+      attr_reader :name
+      # Value that is assigned to class variable, `Int("1")` for `@@foo = 1`
+      #
+      # @return [Node, nil]
+      attr_reader :value
+      # Location of the class variable name
+      #
+      # ```text
+      # @@foo = 1
+      # ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :name_l
+      # Location of the `=` operator
+      #
+      # ```text
+      # @@foo = 1
+      #       ~
+      # ```
+      #
+      # @return [Loc, nil]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # @@foo = 1
+      # ~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents method definition using `def` keyword (not on a singleton, see `Defs` node).
+    class Def < Node
+      # Name of the method, `String("foo")` for `def foo; end`
+      #
+      # @return [String]
+      attr_reader :name
+      # Arguments of a method, `None` if there's no arguments.
+      #
+      # All information about parentheses around arguments is stored in this node.
+      #
+      # @return [Node, nil]
+      attr_reader :args
+      # Body of a method, `None` if there's no body.
+      #
+      # @return [Node, nil]
+      attr_reader :body
+      # Location of the `def` keyword.
+      #
+      # ```text
+      # def foo; end
+      # ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the method name.
+      #
+      # ```text
+      # def foo; end
+      #     ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :name_l
+      # Location of the `end` keyword.
+      #
+      # ```text
+      # def foo; end
+      #          ~~~
+      # ```
+      #
+      # `None` for endless method definition
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the `=` operator for endless method definition
+      #
+      # ```text
+      # def m() = 1
+      #         ~
+      # ```
+      #
+      # `None` for regular method definition
+      #
+      # @return [Loc, nil]
+      attr_reader :assignment_l
+      # Location of the full expression
+      #
+      # ```text
+      # def m(a); foo; end
+      # ~~~~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a `defined?(foo)` expression
+    class Defined < Node
+      # Value given to `defined?`
+      #
+      # @return [Node]
+      attr_reader :value
+      # Location of the `defined?` keyword
+      #
+      # ```text
+      # defined?(foo)
+      # ~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the open parenthesis
+      #
+      # ```text
+      # defined?(foo)
+      #         ~
+      # ```
+      #
+      # `None` if there are no parentheses
+      #
+      # @return [Loc, nil]
+      attr_reader :begin_l
+      # Location of the closing parenthesis
+      #
+      # ```text
+      # defined?(foo)
+      #             ~
+      # ```
+      #
+      # `None` if there are no parentheses
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # defined?(foo)
+      # ~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a singleton method definition (i.e. `def self.foo; end`)
+    class Defs < Node
+      # Definee of a method definition, `Lvar("x")` for `def x.foo; end`
+      #
+      # @return [Node]
+      attr_reader :definee
+      # Name of the method, `String("foo")` for `def x.foo; end`
+      #
+      # @return [String]
+      attr_reader :name
+      # Arguments of a method, `None` if there's no arguments.
+      #
+      # All information about parentheses around arguments is stored in this node.
+      #
+      # @return [Node, nil]
+      attr_reader :args
+      # Body of the method, `None` if there's no body.
+      #
+      # @return [Node, nil]
+      attr_reader :body
+      # Location of the `def` keyword
+      #
+      # ```text
+      # def self.foo; end
+      # ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the `.`
+      #
+      # ```text
+      # def self.foo; end
+      #         ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the method name
+      #
+      # ```text
+      # def self.foo; end
+      #          ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :name_l
+      # Location of the `=` operator for endless method definition
+      #
+      # ```text
+      # def self.foo() = 42
+      #                ~
+      # ```
+      #
+      # `None` for regular method definition
+      #
+      # @return [Loc, nil]
+      attr_reader :assignment_l
+      # Location of the `end` keyword
+      #
+      # ```text
+      # def self.foo; end
+      #               ~~~
+      # ```
+      #
+      # `None` for endless method definition
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # def self.foo; end
+      # ~~~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a string with interpolation (i.e. `"#{foo}"`)
+    class Dstr < Node
+      # A list of string parts (static literals and interpolated expressions)
+      #
+      # @return [::Array<Node>]
+      attr_reader :parts
+      # Location of the string begin
+      #
+      # ```text
+      # "#{foo}"
+      # ~
+      #
+      # %Q{#{foo}}
+      # ~~~
+      # ```
+      #
+      # @return [Loc, nil]
+      attr_reader :begin_l
+      # Location of the string end
+      #
+      # ```text
+      # "#{foo}"
+      #        ~
+      #
+      # %Q{#{foo}}
+      #          ~
+      # ```
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # "#{foo}"
+      # ~~~~~~~~
+      #
+      # %Q{#{foo}}
+      # ~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a symbol with interpolation (i.e. `:"#{foo}"`)
+    class Dsym < Node
+      # A list of symbol parts (static literals and interpolated expressions)
+      #
+      # @return [::Array<Node>]
+      attr_reader :parts
+      # Location of the symbol begin
+      #
+      # ```text
+      # :"#{foo}"
+      # ~~
+      # ```
+      #
+      # `None` if `Dsym` is a part of the interpolated symbol array:
+      #
+      # ```text
+      # %I[#{bar}]
+      # ```
+      #
+      # @return [Loc, nil]
+      attr_reader :begin_l
+      # Location of the symbol begin
+      #
+      # ```text
+      # :"#{foo}"
+      #         ~
+      # ```
+      #
+      # `None` if `Dsym` is a part of the interpolated symbol array:
+      #
+      # ```text
+      # %I[#{bar}]
+      # ```
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # :"#{foo}"
+      # ~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents exclusive flip-flop (i.e. in `if foo...bar; end`)
+    class EFlipFlop < Node
+      # Left part of the flip-flop. `None` if based on a range without begin (`...bar`)
+      #
+      # @return [Node, nil]
+      attr_reader :left
+      # Right part of the flip-flop. `None` if based on a range without end (`foo...`)
+      #
+      # @return [Node, nil]
+      attr_reader :right
+      # Location of the `...` operator
+      #
+      # ```text
+      # if foo...bar; end
+      #       ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # if foo...bar; end
+      #    ~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a special empty else that is a part of the pattern matching.
+    #
+    # Usually empty else (e.g. part of the `if` statement) doesn't mean anything,
+    # however in pattern matching it prevents raising a `NoPatternError`.
+    #
+    # Throwing away this `else` may affect your code.
+    class EmptyElse < Node
+      # Location of the `else` keyword
+      #
+      # ```text
+      # case foo; in 1; else; end
+      #                 ~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a special `__ENCODING__` keyword
+    class Encoding < Node
+      # Location of the `__ENCODING__` keyword
+      #
+      # ```text
+      # __ENCODING__
+      # ~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a block of code with `ensure` (i.e. `begin; ensure; end`)
+    class Ensure < Node
+      # Block of code that is wrapped into `ensure`
+      # **Note**: that's the body of the `ensure` block
+      #
+      # `Int("1")` for `begin; 1; ensure; 2; end`
+      #
+      # @return [Node, nil]
+      attr_reader :body
+      # Body of the `ensure` block
+      #
+      # `Int("2")` for `begin; 1; ensure; 2; end`
+      #
+      # @return [Node, nil]
+      attr_reader :ensure
+      # Location of the `ensure` keyword
+      #
+      # ```text
+      # begin; ensure; end
+      #        ~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the full expression
+      #
+      # ```text
+      # begin; 1; rescue; 2; else; 3; ensure; 4; end
+      #        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      # ```
+      #
+      # **Note**: begin/end belong to `KwBegin` node.
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents range literal with excluded `end` (i.e. `1...3`)
+    class Erange < Node
+      # Begin of the range, `None` if range has no begin (i.e `...42`)
+      #
+      # @return [Node, nil]
+      attr_reader :left
+      # End of the range, `None` if range has no end (i.e `42...`)
+      #
+      # @return [Node, nil]
+      attr_reader :right
+      # Location of the `...` operator
+      #
+      # ```text
+      # 1...3
+      #  ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # 1...3
+      # ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a `false` literal
+    class False < Node
+      # Location of the `false` literal
+      #
+      # ```text
+      # false
+      # ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a special `__FILE__` literal
+    class File < Node
+      # Location of the `__FILE__` literal
+      #
+      # ```text
+      # __FILE__
+      # ~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a find pattern using in pattern matching (i.e. `in [*x, 1 => a, *y]`)
+    #
+    # It's different from `ArrayPattern`/`ConstPattern` because it supports multiple wildcard pattern
+    class FindPattern < Node
+      # Inner part of the find pattern
+      #
+      # @return [::Array<Node>]
+      attr_reader :elements
+      # Location of the begin
+      #
+      # ```text
+      # case foo; in [*x, 1 => a, *y]; end
+      #              ~
+      # ```
+      #
+      # `None` if there are no brackets/parentheses
+      #
+      # @return [Loc, nil]
+      attr_reader :begin_l
+      # Location of the end
+      #
+      # ```text
+      # case foo; in [*x, 1 => a, *y]; end
+      #                             ~
+      # ```
+      #
+      # `None` if there are no brackets/parentheses
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # case foo; in [*x, 1 => a, *y]; end
+      #              ~~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a float literal (i.e. `42.5`)
+    class Float < Node
+      # String value of the literal, `String("42.5")` for `42.5`
+      #
+      # @return [String]
+      attr_reader :value
+      # Location of unary `-` (but not `+`)
+      #
+      # ```text
+      # -42.5
+      # ~
+      # ```
+      #
+      # @return [Loc, nil]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # -42.5
+      # ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a `for` loop
+    class For < Node
+      # Variable that is used in loop, `Lvasgn("a")` in `for a in b; end`
+      #
+      # @return [Node]
+      attr_reader :iterator
+      # Collection that is for iteration. `Lvar("b")` in `for a in b; end`
+      #
+      # @return [Node]
+      attr_reader :iteratee
+      # Body of the loop. `None` if there's no body
+      #
+      # @return [Node, nil]
+      attr_reader :body
+      # Location of the `for` keyword
+      #
+      # ```text
+      # for a in b; end
+      # ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the `in` keyword
+      #
+      # ```text
+      # for a in b; end
+      #       ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the `do` keyword
+      #
+      # ```text
+      # for a in b do; end
+      #            ~~
+      # ```
+      #
+      # **Note**: this `do` is optional, and so `begin_l` can be `None`.
+      #
+      # @return [Loc]
+      attr_reader :begin_l
+      # Location of the `end` keyword
+      #
+      # ```text
+      # for a in b; end
+      #             ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # for a in b; end
+      # ~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a special `...` argument that forwards positional/keyword/block arguments.
+    class ForwardArg < Node
+      # Location of the `...`
+      #
+      # ```text
+      # def m(...); end
+      #       ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a `...` operator that contains forwarded argument (see `ForwardArg`)
+    class ForwardedArgs < Node
+      # Location of the `...`
+      #
+      # ```text
+      # def m(...); foo(...); end
+      #                 ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents access to global variable (i.e. `$foo`)
+    class Gvar < Node
+      # Name of the global variable, `String("$foo")` for `$foo`
+      #
+      # @return [String]
+      attr_reader :name
+      # Location of the full expression
+      #
+      # ```text
+      # $foo
+      # ~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents global variable assignment (i.e. `$foo = 42`)
+    class Gvasgn < Node
+      # Name of the global variable, `String("$foo")` for `$foo`
+      #
+      # @return [String]
+      attr_reader :name
+      # Value that is assigned to global variable, `Int("42")` for `$foo = 42`
+      #
+      # `None` if global variable assignment is a part of the multi-assignment.
+      # In such case `value` is a part of the `Masgn` node.
+      #
+      # @return [Node, nil]
+      attr_reader :value
+      # Location of the global variable name
+      #
+      # ```text
+      # $foo = 42
+      # ~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :name_l
+      # Location of the `=` operator
+      #
+      # ```text
+      # $foo = 42
+      #      ~
+      # ```
+      #
+      # `None` if global variable assignment is a part of the multi-assignment.
+      # In such case `=` operator belongs to the `Masgn` node.
+      #
+      # @return [Loc, nil]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # $foo = 42
+      # ~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a hash literal (i.e. `{ foo: 42 }`)
+    class Hash < Node
+      # A list of key-value pairs
+      #
+      # @return [::Array<Node>]
+      attr_reader :pairs
+      # Location of the open parenthesis
+      #
+      # ```text
+      # { a: 1 }
+      # ~
+      # ```
+      #
+      # `None` if hash literal is implicit, e.g. `foo(key: "value")`
+      #
+      # @return [Loc, nil]
+      attr_reader :begin_l
+      # Location of the closing parenthesis
+      #
+      # ```text
+      # { a: 1 }
+      #        ~
+      # ```
+      #
+      # `None` if hash literal is implicit, e.g. `foo(key: "value")`
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # { a: 1 }
+      # ~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a hash pattern used in pattern matching (i.e. `in { a: 1 }`)
+    class HashPattern < Node
+      # A list of inner patterns
+      #
+      # @return [::Array<Node>]
+      attr_reader :elements
+      # Location of the open parenthesis
+      #
+      # ```text
+      # case foo; in { a: 1 }; end
+      #              ~
+      # ```
+      #
+      # `None` if there are no parentheses
+      #
+      # @return [Loc, nil]
+      attr_reader :begin_l
+      # Location of the open parenthesis
+      #
+      # ```text
+      # case foo; in { a: 1 }; end
+      #                     ~
+      # ```
+      #
+      # `None` if there are no parentheses
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # case foo; in { a: 1 }; end
+      #              ~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a here-document literal (both with and without interpolation)
+    #
+    # It's similar to `Dstr` in terms of abstract syntax tree, but has different source maps.
+    class Heredoc < Node
+      # A list of string parts (static literals and interpolated expressions)
+      #
+      # @return [::Array<Node>]
+      attr_reader :parts
+      # Location of the here-document body
+      #
+      # ```text
+      # <<-HERE\n  a\n   #{42}\nHERE
+      # ~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :heredoc_body_l
+      # Location of the here-document end
+      #
+      # ```text
+      # <<-HERE\n  a\n   #{42}\nHERE
+      #                         ~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :heredoc_end_l
+      # Location of the here-document identifier
+      #
+      # ```text
+      # <<-HERE\n  a\n   #{42}\nHERE
+      # ~~~~~~~
+      # ```
+      #
+      # **Note**: This is the only node (with `XHeredoc`) that has `expression_l` smaller that all other sub-locations merged.
+      # The reason for that is that it's possible to add more code after here-document ID:
+      #
+      # ```text
+      # <<-HERE + "rest"
+      # content
+      # HERE
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents an `if` statement (i.e. `if foo; bar; else; baz; end`)
+    class If < Node
+      # Condition given to the `if` statement, `Lvar("a")` for `if a; b; else; c; end`
+      #
+      # @return [Node]
+      attr_reader :cond
+      # True-branch of the `if` statement, `Lvar("b")` for `if a; b; else; c; end`
+      #
+      # @return [Node, nil]
+      attr_reader :if_true
+      # False-branch of the `if` statement, `Lvar("c")` for `if a; b; else; c; end`
+      #
+      # @return [Node, nil]
+      attr_reader :if_false
+      # Location of the `if` keyword
+      #
+      # ```text
+      # if foo; end
+      # ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the `then` keyword
+      #
+      # ```text
+      # if foo then; end
+      #        ~~~~
+      # ```
+      #
+      # `None` if `then` keyword is omitted
+      #
+      # @return [Loc]
+      attr_reader :begin_l
+      # Location of the `else` keyword
+      #
+      # ```text
+      # if foo; else; end
+      #         ~~~~
+      # ```
+      #
+      # `None` if there's no `else` branch
+      #
+      # @return [Loc, nil]
+      attr_reader :else_l
+      # Location of the `end` keyword
+      #
+      # ```text
+      # if foo; end
+      #         ~~~
+      # ```
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # if a then; b; else; c end
+      # ~~~~~~~~~~~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents an `if` guard used in pattern matching (i.e. `case foo; in pattern if guard; end`)
+    class IfGuard < Node
+      # Condition of the guard, `Lvar("foo")` in `in pattern if guard`
+      #
+      # @return [Node]
+      attr_reader :cond
+      # Location of the `if` keyword
+      #
+      # ```text
+      # case foo; in pattern if cond; end
+      #                      ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the full expression
+      #
+      # ```text
+      # case foo; in pattern if cond; end
+      #                      ~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents inclusive flip-flop (i.e. in `if foo..bar; end`)
+    class IFlipFlop < Node
+      # Left part of the flip-flop. `None` if based on a range without begin (`..bar`)
+      #
+      # @return [Node, nil]
+      attr_reader :left
+      # Right part of the flip-flop. `None` if based on a range without end (`foo..`)
+      #
+      # @return [Node, nil]
+      attr_reader :right
+      # Location of the `..` operator
+      #
+      # ```text
+      # if foo..bar; end
+      #       ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # if foo..bar; end
+      #    ~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents an `if`/`unless` modifier (i.e. `stmt if cond`)
+    class IfMod < Node
+      # Condition of the modifier
+      #
+      # @return [Node]
+      attr_reader :cond
+      # True-branch of the modifier.
+      #
+      # Always set for `if` modifier.
+      # Always `None` for `unless` modifier.
+      #
+      # @return [Node, nil]
+      attr_reader :if_true
+      # False-branch of the modifier.
+      #
+      # Always set for `unless` modifier.
+      # Always `None` for `if` modifier.
+      #
+      # @return [Node, nil]
+      attr_reader :if_false
+      # Location of the `if`/`unless` keyword
+      #
+      # ```text
+      # stmt if cond
+      #      ~~
+      #
+      # stmt unless cond
+      #      ~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the full expression
+      #
+      # ```text
+      # stmt if cond
+      # ~~~~~~~~~~~~
+      #
+      # stmt unless cond
+      # ~~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents ternary `if` statement (i.e. `cond ? if_true : if_false`)
+    class IfTernary < Node
+      # Condition of the `if` statement
+      #
+      # @return [Node]
+      attr_reader :cond
+      # True-branch
+      #
+      # @return [Node]
+      attr_reader :if_true
+      # True-branch
+      #
+      # @return [Node]
+      attr_reader :if_false
+      # Location of the `?` operator
+      #
+      # ```text
+      # cond ? if_true : if_false
+      #      ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :question_l
+      # Location of the `:` operator
+      #
+      # ```text
+      # cond ? if_true : if_false
+      #                ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :colon_l
+      # Location of the full expression
+      #
+      # ```text
+      # cond ? if_true : if_false
+      # ~~~~~~~~~~~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents indexing operation (i.e. `foo[1,2,3]`)
+    class Index < Node
+      # Receiver of indexing
+      #
+      # @return [Node]
+      attr_reader :recv
+      # A list of indexes
+      #
+      # @return [::Array<Node>]
+      attr_reader :indexes
+      # Location of open bracket
+      #
+      # ```text
+      # foo[1, 2, 3]
+      #    ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :begin_l
+      # Location of closing bracket
+      #
+      # ```text
+      # foo[1, 2, 3]
+      #            ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # foo[1, 2, 3]
+      # ~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents assignment using indexing operation (i.e. `foo[1, 2, 3] = bar`)
+    class IndexAsgn < Node
+      # Receiver of the indexing
+      #
+      # @return [Node]
+      attr_reader :recv
+      # A list of indexes
+      #
+      # @return [::Array<Node>]
+      attr_reader :indexes
+      # Value that is assigned
+      #
+      # `None` if assignment is a part of the multi-assignment.
+      # In such case `value` belongs to `Masgn` node.
+      #
+      # @return [Node, nil]
+      attr_reader :value
+      # Location of open bracket
+      #
+      # ```text
+      # foo[1, 2, 3] = bar
+      #    ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :begin_l
+      # Location of closing bracket
+      #
+      # ```text
+      # foo[1, 2, 3] = bar
+      #            ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :end_l
+      # Location of the `=` operator
+      #
+      # ```text
+      # foo[1, 2, 3] = bar
+      #              ~
+      # ```
+      #
+      # `None` if assignment is a part of the multi-assignment.
+      # In such case operator `=` belongs to `Masgn` node.
+      #
+      # @return [Loc, nil]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # foo[1, 2, 3] = bar
+      # ~~~~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents an `in pattern` branch of the pattern matching
+    class InPattern < Node
+      # Value that is used for matching
+      #
+      # @return [Node]
+      attr_reader :pattern
+      # Guard that is used for matching
+      #
+      # Optional, so can be `None`
+      #
+      # @return [Node, nil]
+      attr_reader :guard
+      # Body of the branch that is invoked if value matches pattern
+      #
+      # @return [Node, nil]
+      attr_reader :body
+      # Location of the `in` keyword
+      #
+      # ```text
+      # case value; in pattern; end
+      #             ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the `then` keyword
+      #
+      # ```text
+      # case value; in pattern then; end
+      #                        ~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :begin_l
+      # Location of the full expression
+      #
+      # ```text
+      # case value; in pattern then; 42; end
+      #             ~~~~~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents an integer literal (i.e. `42`)
+    class Int < Node
+      # String value of the literal, `String("42")` for `42`
+      #
+      # @return [String]
+      attr_reader :value
+      # Location of unary `-` (but not `+`)
+      #
+      # ```text
+      # -42
+      # ~
+      # ```
+      #
+      # @return [Loc, nil]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # -42
+      # ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents inclusive range (i.e. `2..4`)
+    class Irange < Node
+      # Begin of the range, `None` if range has no `begin` (i.e. `..4`)
+      #
+      # @return [Node, nil]
+      attr_reader :left
+      # End of the range, `None` if range has no `end` (i.e. `2..`)
+      #
+      # @return [Node, nil]
+      attr_reader :right
+      # Location of the `..` operator
+      #
+      # ```text
+      # 2..4
+      #  ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # 2..4
+      # ~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents access to instance variable (i.e. `@foo`)
+    class Ivar < Node
+      # Name of the instance variable, `String("@foo")` in `@foo`
+      #
+      # @return [String]
+      attr_reader :name
+      # Location of the full expression
+      #
+      # ```text
+      # @foo
+      # ~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents instance variable assignment (i.e `@foo = 42`)
+    class Ivasgn < Node
+      # Name of the instance variable, `String("@foo")` in `@foo = 42`
+      #
+      # @return [String]
+      attr_reader :name
+      # Value that is assigned to instance variable.
+      #
+      # `None` if instance variable assignment is a part of the multi-assignment.
+      # In such case `value` is a part of the `Masgn` node.
+      #
+      # @return [Node, nil]
+      attr_reader :value
+      # Location of the instance variable name.
+      #
+      # ```text
+      # @foo = 1
+      # ~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :name_l
+      # Location of the `=` operator.
+      #
+      # ```text
+      # @foo = 1
+      #      ~
+      # ```
+      #
+      # `None` if instance variable assignment is a part of the multi-assignment.
+      # In such case `value` is a part of the `Masgn` node.
+      #
+      # @return [Loc, nil]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # @foo = 42
+      # ~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents required keyword argument (i.e. `foo` in `def m(foo:); end`)
+    class Kwarg < Node
+      # Name of the keyword argument
+      #
+      # @return [String]
+      attr_reader :name
+      # Location of the name
+      #
+      # ```text
+      # def foo(bar:); end
+      #         ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :name_l
+      # Location of the full expression
+      #
+      # ```text
+      # def foo(bar:); end
+      #         ~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents kwargs that are given to a method call, super or yield (i.e. `foo(bar: 1)`)
+    class Kwargs < Node
+      # A list of key-value pairs
+      #
+      # @return [::Array<Node>]
+      attr_reader :pairs
+      # Location of the full expression
+      #
+      # ```text
+      # foo(bar: 1)
+      #     ~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents an explicit `begin; end` block.
+    #
+    # The reason why it's different is that
+    # ```text
+    # begin; foo; end while cond
+    # ```
+    # is a post-while loop (same with post-until loop)
+    class KwBegin < Node
+      # A list of statements
+      #
+      # @return [::Array<Node>]
+      attr_reader :statements
+      # Location of the `begin` keyword
+      #
+      # ```text
+      # begin; foo; end
+      # ~~~~~
+      # ```
+      #
+      # @return [Loc, nil]
+      attr_reader :begin_l
+      # Location of the `end` keyword
+      #
+      # ```text
+      # begin; foo; end
+      #             ~~~
+      # ```
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # begin; foo; bar
+      # ~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents an special argument that rejects all keyword arguments (i.e. `def m(**nil); end`)
+    class Kwnilarg < Node
+      # Location of the `nil`
+      #
+      # ```text
+      # def m(**nil); end
+      #         ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :name_l
+      # Location of the `nil`
+      #
+      # ```text
+      # def m(**nil); end
+      #       ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents an optional keyword argument (i.e. `foo` in `def m(foo: 42); end`)
+    class Kwoptarg < Node
+      # Name of the optional keyword argument
+      #
+      # @return [String]
+      attr_reader :name
+      # Default value of the optional keyword argument
+      #
+      # @return [Node]
+      attr_reader :default
+      # Location of the argument name
+      #
+      # ```text
+      # def m(foo: 1); end
+      #       ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :name_l
+      # Location of the argument name
+      #
+      # ```text
+      # def m(foo: 1); end
+      #       ~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a keyword rest argument (i.e. `foo` in `def m(**foo); end`)
+    class Kwrestarg < Node
+      # Name of the keyword rest argument, `String("foo")` in `def m(**foo); end`.
+      #
+      # `None` if argument has no name (`def m(**); end`)
+      #
+      # @return [String, nil]
+      attr_reader :name
+      # Location of the `**` operator
+      #
+      # ```text
+      # def m(**foo); end
+      #       ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the argument name
+      #
+      # ```text
+      # def m(**foo); end
+      #         ~~~
+      # ```
+      #
+      # `None` if argument has no name (`def m(**); end`)
+      #
+      # @return [Loc, nil]
+      attr_reader :name_l
+      # Location of the full expression
+      #
+      # ```text
+      # def m(**foo); end
+      #       ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a keyword arguments splat (i.e. `**bar` in a call like `foo(**bar)`)
+    class Kwsplat < Node
+      # Value that is converted into a `Hash` using `**`
+      #
+      # @return [Node]
+      attr_reader :value
+      # Location of the `**` operator
+      #
+      # ```text
+      # foo(**bar)
+      #     ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # foo(**bar)
+      #     ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a lambda call using `->` (i.e. `-> {}`)
+    #
+    # Note that `Lambda` is a part of the `Block`, not other way around.
+    class Lambda < Node
+      # Location of the `->`
+      #
+      # ```text
+      # -> {}
+      # ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a special `__LINE__` literal
+    class Line < Node
+      # Location of the `__LINE__` literal
+      #
+      # ```text
+      # __LINE__
+      # ~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents access to a local variable (i.e. `foo`)
+    #
+    # Parser knows that it's a local variable because:
+    # 1. there was an assignment to this variable **before** accessing it
+    # 2. it's an argument of the current method / block
+    # 3. it's been implicitly declared by `MatchWithLvasgn` node
+    #
+    # Otherwise it's a method call (see `Send`)
+    class Lvar < Node
+      # Name of the local variable
+      #
+      # @return [String]
+      attr_reader :name
+      # Location of the local variable
+      #
+      # ```text
+      # foo
+      # ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents local variable assignment (i.e. `foo = 42`)
+    class Lvasgn < Node
+      # Name of the local variable
+      #
+      # @return [String]
+      attr_reader :name
+      # Value that is assigned to a local variable
+      #
+      # @return [Node, nil]
+      attr_reader :value
+      # Location of the local variable name
+      #
+      # ```text
+      # foo = 42
+      # ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :name_l
+      # Location of the `=` operator
+      #
+      # ```text
+      # foo = 42
+      #     ~
+      # ```
+      #
+      # `None` if local variable assignment is a part of the multi-assignment.
+      # In such case `value` is a part of the `Masgn` node.
+      #
+      # @return [Loc, nil]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # foo = 42
+      # ~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents mass-assignment (i.e. `foo, bar = 1, 2`)
+    class Masgn < Node
+      # Left hand statement of the assignment
+      #
+      # @return [Node]
+      attr_reader :lhs
+      # Left hand statement of the assignment
+      #
+      # @return [Node]
+      attr_reader :rhs
+      # Location of the `=` operator
+      #
+      # ```text
+      # foo, bar = 1, 2
+      #          ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # foo, bar = 1, 2
+      # ~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents pattern matching using one of the given patterns (i.e. `foo in 1 | 2`)
+    class MatchAlt < Node
+      # Left pattern
+      #
+      # @return [Node]
+      attr_reader :lhs
+      # Right pattern
+      #
+      # @return [Node]
+      attr_reader :rhs
+      # Location of the `|` operator
+      #
+      # ```text
+      # foo in 1 | 2
+      #          ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # foo in 1 | 2
+      #        ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents matching with renaming into specified local variable (i.e. `case 1; in Integer => a; end`)
+    class MatchAs < Node
+      # Pattern that is used for matching
+      #
+      # @return [Node]
+      attr_reader :value
+      # Variable that is assigned if matched (see `MatchVar` node)
+      #
+      # @return [Node]
+      attr_reader :as
+      # Location of the `=>` operator
+      #
+      # ```text
+      # case 1; in Integer => a; end
+      #                    ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # case 1; in Integer => a; end
+      #            ~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents implicit matching using `if /regex/`
+    #
+    # ```text
+    # if /.*/
+    # puts 'true'
+    # else
+    # puts 'false'
+    # end
+    # ```
+    # Prints "false".
+    #
+    # Under the hood this construction matches regex against `$_`, so the following works:
+    # ```text
+    # $_ = 'match_me'
+    # if /match_me/
+    # puts 'true'
+    # else
+    # puts 'false'
+    # end
+    # ```
+    # this code prints "true".
+    class MatchCurrentLine < Node
+      # Given regex
+      #
+      # @return [Node]
+      attr_reader :re
+      # Location of the regex
+      #
+      # ```text
+      # if /re/; end
+      #    ~~~~
+      # ```
+      #
+      # Technically this location is redundant, but keeping it is the only way to
+      # have the same interface for all nodes.
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents empty hash pattern that is used in pattern matching (i.e. `in **nil`)
+    class MatchNilPattern < Node
+      # Location of the `**` operator
+      #
+      # ```text
+      # in **nil
+      #    ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the name
+      #
+      # ```text
+      # in **nil
+      #      ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :name_l
+      # Location of the full expression
+      #
+      # ```text
+      # in **nil
+      #    ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a one-line pattern matching that can throw an error (i.e. `foo => pattern`)
+    class MatchPattern < Node
+      # Value that is used for matching
+      #
+      # @return [Node]
+      attr_reader :value
+      # Pattern that is used for matching
+      #
+      # @return [Node]
+      attr_reader :pattern
+      # Location of the `=>` operator
+      #
+      # ```text
+      # foo => pattern
+      #     ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # foo => pattern
+      # ~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a one-line pattern matching that never throws but returns true/false (i.e. `foo in pattern`)
+    class MatchPatternP < Node
+      # Value that is used for matching
+      #
+      # @return [Node]
+      attr_reader :value
+      # Pattern that is used for matching
+      #
+      # @return [Node]
+      attr_reader :pattern
+      # Location of the `in` operator
+      #
+      # ```text
+      # foo in pattern
+      #     ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # foo in pattern
+      # ~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a wildcard pattern used in pattern matching (i.e. `in *foo`)
+    class MatchRest < Node
+      # Name of the variable name
+      #
+      # `None` if there's no name (i.e. `in *`)
+      #
+      # @return [Node, nil]
+      attr_reader :name
+      # Location of the `*` operator
+      #
+      # ```text
+      # case foo; in *bar; end
+      #              ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the `*` operator
+      #
+      # ```text
+      # case foo; in *bar; end
+      #              ~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents matching with assignment into a local variable (i.e. `pattern => var`)
+    class MatchVar < Node
+      # Name of the variable that is assigned if matching succeeds
+      #
+      # @return [String]
+      attr_reader :name
+      # Location of the name
+      #
+      # ```text
+      # case foo; in pattern => bar; end
+      #                         ~~~
+      # ```
+      #
+      # **Note** it can also be produced by a hash pattern
+      #
+      # ```text
+      # case foo; in { a: }; end
+      #                ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :name_l
+      # Location of the full expression
+      #
+      # ```text
+      # case foo; in pattern => bar; end
+      #                         ~~~
+      # ```
+      #
+      # **Note** it can also be produced by a hash pattern
+      #
+      # ```text
+      # case foo; in { a: }; end
+      #                ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents matching a regex that produces local variables (i.e. `/(?<match>bar)/ =~ 'bar'`)
+    #
+    # Each named group in regex declares a local variable.
+    class MatchWithLvasgn < Node
+      # Regex that is used for matching
+      #
+      # @return [Node]
+      attr_reader :re
+      # Value that is used for matching
+      #
+      # @return [Node]
+      attr_reader :value
+      # Location of the `=~` operatir
+      #
+      # ```text
+      # /(?<match>bar)/ =~ 'bar'
+      #                 ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # /(?<match>bar)/ =~ 'bar'
+      # ~~~~~~~~~~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents left hand statement of the mass-assignment (i.e. `foo, bar` in `foo, bar = 1, 2`)
+    class Mlhs < Node
+      # A list of items that are assigned
+      #
+      # @return [::Array<Node>]
+      attr_reader :items
+      # Location of the open parenthesis
+      #
+      # ```text
+      # (a, b) = 1, 2
+      # ~
+      # ```
+      #
+      # `None` if there are no parentheses
+      #
+      # @return [Loc, nil]
+      attr_reader :begin_l
+      # Location of the closing parenthesis
+      #
+      # ```text
+      # (a, b) = 1, 2
+      #      ~
+      # ```
+      #
+      # `None` if there are no parentheses
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # (a, b) = 1, 2
+      # ~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents module declaration using `module` keyword
+    class Module < Node
+      # Name of the module
+      #
+      # @return [Node]
+      attr_reader :name
+      # Body of the module
+      #
+      # `None` if module has no body
+      #
+      # @return [Node, nil]
+      attr_reader :body
+      # Location of the `module` keyword
+      #
+      # ```text
+      # module M; end
+      # ~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the `end` keyword
+      #
+      # ```text
+      # module M; end
+      #           ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # module M; end
+      # ~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents `next` keyword
+    class Next < Node
+      # Arguments given to `next`
+      #
+      # @return [::Array<Node>]
+      attr_reader :args
+      # Location of the `next` keyword
+      #
+      # ```text
+      # next 42
+      # ~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the full expression
+      #
+      # ```text
+      # next(42)
+      # ~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents `nil` literal
+    class Nil < Node
+      # Location of the `nil` keyword
+      #
+      # ```text
+      # nil
+      # ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents numeric global variable (e.g. `$1`)
+    class NthRef < Node
+      # Name of the variable, `String("1")` for `$1`
+      #
+      # @return [String]
+      attr_reader :name
+      # Location of the full expression
+      #
+      # ```text
+      # $1
+      # ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a block that takes numbered parameters (i.e. `proc { _1 }`)
+    class Numblock < Node
+      # Method call that takes a block
+      #
+      # @return [Node]
+      attr_reader :call
+      # Number of parameters that block takes
+      #
+      # @return [Integer]
+      attr_reader :numargs
+      # Block body
+      #
+      # @return [Node]
+      attr_reader :body
+      # Location of the open brace
+      #
+      # ```text
+      # proc { _1 }
+      #      ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :begin_l
+      # Location of the closing brace
+      #
+      # ```text
+      # proc { _1 }
+      #           ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :end_l
+      # Location of the open brace
+      #
+      # ```text
+      # proc { _1 }
+      # ~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents an operation with assignment (e.g. `a += 1`)
+    class OpAsgn < Node
+      # Left hand statement of the assignment
+      #
+      # @return [Node]
+      attr_reader :recv
+      # Operator, can be one of:
+      # 1. `+=`
+      # 2. `-=`
+      # 3. `*=`
+      # 4. `/=`
+      # 5. `|=`
+      # 6. `&=`
+      # 7. `>>=`
+      # 8. `<<=`
+      # 9. `%=`
+      # 10. `^=`
+      # 11. `**=`
+      #
+      # @return [String]
+      attr_reader :operator
+      # Right hand statement of the assignment
+      #
+      # @return [Node]
+      attr_reader :value
+      # Location of the operator
+      #
+      # ```text
+      # a.b <<= c
+      #     ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the operator
+      #
+      # ```text
+      # a.b <<= c
+      # ~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents optional positional argument (i.e. `foo` in `m(foo = 1)`)
+    class Optarg < Node
+      # Name of the argument
+      #
+      # @return [String]
+      attr_reader :name
+      # Default value of the argument
+      #
+      # @return [Node]
+      attr_reader :default
+      # Location of the argument name
+      #
+      # ```text
+      # def m(foo = 1); end
+      #       ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :name_l
+      # Location of the `=` operator
+      #
+      # ```text
+      # def m(foo = 1); end
+      #           ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # def m(foo = 1); end
+      #       ~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents `foo || bar` (or `foo or bar`) statement.
+    class Or < Node
+      # Left hand statement
+      #
+      # @return [Node]
+      attr_reader :lhs
+      # Right hand statement
+      #
+      # @return [Node]
+      attr_reader :rhs
+      # Location of the `||`/`or` operator
+      #
+      # ```text
+      # foo || bar
+      #     ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # foo || bar
+      # ~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents `lhs ||= rhs` assignment
+    class OrAsgn < Node
+      # Left hand statement
+      #
+      # @return [Node]
+      attr_reader :recv
+      # Right hand statement
+      #
+      # @return [Node]
+      attr_reader :value
+      # Location of the `||=` operator
+      #
+      # ```text
+      # foo ||= bar
+      #     ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # foo ||= bar
+      # ~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a key/value pair (e.g. a part of the `Hash` node)
+    class Pair < Node
+      # Key of the pair
+      #
+      # @return [Node]
+      attr_reader :key
+      # Value of the pair
+      #
+      # @return [Node]
+      attr_reader :value
+      # Location of the `:` or `=>` operator
+      #
+      # ```text
+      # { foo: bar }
+      #      ~
+      #
+      # { :foo => bar }
+      #        ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # { foo: bar }
+      #   ~~~~~~~~
+      #
+      # { :foo => bar }
+      #   ~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a pattern based on a "pinned" variable (e.g. `^foo`)
+    class Pin < Node
+      # Variable that is pinned
+      #
+      # @return [Node]
+      attr_reader :var
+      # Location of the `^` operator
+      #
+      # ```text
+      # case foo; in ^bar; end
+      #              ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :selector_l
+      # Location of the full expression
+      #
+      # ```text
+      # case foo; in ^bar; end
+      #              ~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents `END { .. }` statement
+    class Postexe < Node
+      # Body of the block
+      #
+      # @return [Node, nil]
+      attr_reader :body
+      # Location of the `END` keyword
+      #
+      # ```text
+      # END { 42 }
+      # ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the open parenthesis
+      #
+      # ```text
+      # END { 42 }
+      #     ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :begin_l
+      # Location of the closing parenthesis
+      #
+      # ```text
+      # END { 42 }
+      #          ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # END { 42 }
+      # ~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents `BEGIN { ... }` statement
+    class Preexe < Node
+      # Body of the block
+      #
+      # @return [Node, nil]
+      attr_reader :body
+      # Location of the `BEGIN` keyword
+      #
+      # ```text
+      # BEGIN { 42 }
+      # ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the open parenthesis
+      #
+      # ```text
+      # BEGIN { 42 }
+      #       ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :begin_l
+      # Location of the closing parenthesis
+      #
+      # ```text
+      # BEGIN { 42 }
+      #            ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # BEGIN { 42 }
+      # ~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a sole block argument (e.g. `|foo|`)
+    #
+    # Block that takes a single array argument automatically expands it.
+    # Adding trailing comma after block argument disables this behavior (and then the only argument is emitted as `Arg`).
+    class Procarg0 < Node
+      # Parts of the sole block argument.
+      #
+      # `proc { |(a, b)| }` also counts as a sole argument, so this list may contain:
+      # 1. A single `Arg` node (for `proc { |a| }` case)
+      # 2. Multiple `Arg` nodes  (for `proc { |(a, b, c)| }` case)
+      #
+      # @return [::Array<Node>]
+      attr_reader :args
+      # Location of the open parenthesis
+      #
+      # ```text
+      # proc { |(foo, bar)| }
+      #         ~
+      # ```
+      #
+      # `None` if there's only one argument
+      #
+      # @return [Loc, nil]
+      attr_reader :begin_l
+      # Location of the open parenthesis
+      #
+      # ```text
+      # proc { |(foo, bar)| }
+      #                  ~
+      # ```
+      #
+      # `None` if there's only one argument
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # proc { |(foo, bar)| }
+      #         ~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents rational literal (e.g. `1r`)
+    class Rational < Node
+      # String value of the literal, `String("1r")` for `1r`
+      #
+      # @return [String]
+      attr_reader :value
+      # Location of the unary `-` (but not `+`)
+      #
+      # ```text
+      # -1r
+      # ~
+      # ```
+      #
+      # @return [Loc, nil]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # -1r
+      # ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents `redo` keyword
+    class Redo < Node
+      # Location of the full expression
+      #
+      # ```text
+      # redo
+      # ~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents regex literal (e.g. `/foo/`)
+    class Regexp < Node
+      # A list of static and dynamic regex parts
+      #
+      # @return [::Array<Node>]
+      attr_reader :parts
+      # Regex options.
+      #
+      # `None` if regex has no explicit flags
+      #
+      # @return [Node, nil]
+      attr_reader :options
+      # Location of the regex begin
+      #
+      # ```text
+      # /foo/
+      # ~
+      #
+      # %r{foo}
+      # ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :begin_l
+      # Location of the regex end
+      #
+      # ```text
+      # /foo/
+      #     ~
+      #
+      # %r{foo}
+      #       ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # /foo/mix
+      # ~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents flags of the regex literal (i.e. `mix` for `/foo/mix`)
+    class RegOpt < Node
+      # A list of flags
+      #
+      # @return [String, nil]
+      attr_reader :options
+      # Location of the full expression
+      #
+      # ```text
+      # /foo/mix
+      #      ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a `rescue` block
+    class Rescue < Node
+      # Body of the block that is wrapped into `rescue` (i.e. the part that may throw an error)
+      #
+      # @return [Node, nil]
+      attr_reader :body
+      # A list of `rescue` handlers (see `RescueBody` node)
+      #
+      # @return [::Array<Node>]
+      attr_reader :rescue_bodies
+      # Else branch.
+      #
+      # `None` if there's no `else` branch
+      #
+      # @return [Node, nil]
+      attr_reader :else
+      # Location of the `else` keyword
+      #
+      # ```text
+      # begin; 1; rescue StandardError => e; 2; else; 3; end
+      #                                         ~~~~
+      # ```
+      #
+      # `None` if there's no `else` branch
+      #
+      # @return [Loc, nil]
+      attr_reader :else_l
+      # Location of the full expression
+      #
+      # ```text
+      # begin; 1; rescue StandardError => e; 2; else; 3; end
+      #        ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      # ```
+      #
+      # **Note**: `begin/end` keywords belong to `KwBegin` node
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a single `rescue` handler (i.e. `rescue E => e ...`)
+    class RescueBody < Node
+      # A list of exception classes
+      #
+      # `None` if no classes specified (i.e. `rescue => e; ...` or just `rescue; ...`)
+      #
+      # @return [Node, nil]
+      attr_reader :exc_list
+      # Variable that captures exception
+      #
+      # `None` if no variable specified (i.e. `rescue E; ...` or just `rescue; ... `)
+      #
+      # @return [Node, nil]
+      attr_reader :exc_var
+      # Body of the handler
+      #
+      # @return [Node, nil]
+      attr_reader :body
+      # Location of the `rescue` keyword
+      #
+      # ```text
+      # begin; 1; rescue E => e; 2; end
+      #           ~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the `=>` operator
+      #
+      # ```text
+      # begin; 1; rescue E => e; 2; end
+      #                    ~~
+      # ```
+      #
+      # `None` if exception is not captured.
+      #
+      # @return [Loc, nil]
+      attr_reader :assoc_l
+      # Location of the `then` keyword
+      #
+      # ```text
+      # begin; 1; rescue E => e then; 2; end
+      #                         ~~~~
+      # ```
+      #
+      # `then` is optional, so `begin_l` can be `None`
+      #
+      # @return [Loc, nil]
+      attr_reader :begin_l
+      # Location of the full expression
+      #
+      # ```text
+      # begin; 1; rescue E => e then; 2; end
+      #           ~~~~~~~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents positional rest argument (i.e. `*foo` in `def m(*foo); end`)
+    class Restarg < Node
+      # Name of the argument.
+      #
+      # `None` if argument has no name (i.e. `def m(*); end`)
+      #
+      # @return [String, nil]
+      attr_reader :name
+      # Location of the `*` operator
+      #
+      # ```text
+      # def m(*foo); end
+      #       ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the argument name
+      #
+      # ```text
+      # def m(*foo); end
+      #        ~~~
+      # ```
+      #
+      # @return [Loc, nil]
+      attr_reader :name_l
+      # Location of the full expression
+      #
+      # ```text
+      # def m(*foo); end
+      #       ~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents `retry` keyword
+    class Retry < Node
+      # Location of the `retry` keyword
+      #
+      # ```text
+      # retry
+      # ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents `return` keyword
+    class Return < Node
+      # A list of values that is returned
+      #
+      # @return [::Array<Node>]
+      attr_reader :args
+      # Location of the `return` keyword
+      #
+      # ```text
+      # return 1, 2
+      # ~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the full expression
+      #
+      # ```text
+      # return 1, 2
+      # ~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents opening a singleton class (i.e. `class << foo; ... end;`)
+    class SClass < Node
+      # Expression that is used to get a singleton class
+      #
+      # `Lvar("foo")` for `class << foo; end`
+      #
+      # @return [Node]
+      attr_reader :expr
+      # Body of the block
+      #
+      # @return [Node, nil]
+      attr_reader :body
+      # Location of the `class` keyword
+      #
+      # ```text
+      # class << foo; end
+      # ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the `<<` operator
+      #
+      # ```text
+      # class << foo; end
+      #       ~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the `end` keyword
+      #
+      # ```text
+      # class << foo; end
+      #               ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # class << foo; end
+      # ~~~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents `self` keyword
+    class Self_ < Node
+      # Location of the `self` keyword
+      #
+      # ```text
+      # self
+      # ~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a method call (e.g. `foo.bar(42)`)
+    class Send < Node
+      # Receiver of the method call
+      #
+      # `None` for implicit method call (e.g. `foo(42)`)
+      #
+      # @return [Node, nil]
+      attr_reader :recv
+      # Name of the method that is called
+      #
+      # @return [String]
+      attr_reader :method_name
+      # A list of arguments
+      #
+      # @return [::Array<Node>]
+      attr_reader :args
+      # Location of the `.` operator
+      #
+      # ```text
+      # foo.bar(42)
+      #    ~
+      # ```
+      #
+      # `None` for implicit method call (e.g. `foo(42)`)
+      #
+      # @return [Loc, nil]
+      attr_reader :dot_l
+      # Location of the method name
+      #
+      # ```text
+      # foo.bar(42)
+      #     ~~~
+      # ```
+      #
+      # `None` in a very special case when method call is implicit (i.e. `foo.(42)`)
+      #
+      # @return [Loc, nil]
+      attr_reader :selector_l
+      # Location of open parenthesis
+      #
+      # ```text
+      # foo(42)
+      #    ~
+      # ```
+      #
+      # `None` if there are no parentheses
+      #
+      # @return [Loc, nil]
+      attr_reader :begin_l
+      # Location of closing parenthesis
+      #
+      # ```text
+      # foo(42)
+      #       ~
+      # ```
+      #
+      # `None` if there are no parentheses
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the operator if method is a setter
+      #
+      # ```text
+      # foo.bar = 42
+      #         ~
+      # ```
+      #
+      # `None` otherwise
+      #
+      # @return [Loc, nil]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # foo.bar(42)
+      # ~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a special block argument that "shadows" outer variable (i.e. `|;foo|`)
+    class Shadowarg < Node
+      # Name of the argument
+      #
+      # @return [String]
+      attr_reader :name
+      # Location of the argument
+      #
+      # ```text
+      # proc { |;foo|}
+      #          ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents an arguments splat (i.e. `*bar` in a call like `foo(*bar)`)
+    class Splat < Node
+      # Value that is converted to array
+      #
+      # @return [Node, nil]
+      attr_reader :value
+      # Location of the `*` operator
+      #
+      # ```text
+      # foo(*bar)
+      #     ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :operator_l
+      # Location of the full expression
+      #
+      # ```text
+      # foo(*bar)
+      #     ~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a plain non-interpolated string literal (e.g. `"foo"`)
+    class Str < Node
+      # Value of the string literal
+      #
+      # Note that it's a `StringValue`, not a `String`.
+      # The reason is that you can get UTF-8 incompatible strings
+      # from a valid UTF-8 source using escape sequences like `"\xFF"`
+      #
+      # These "\", "x", "F", "F" chars are valid separately, but together
+      # they construct a char with code = 255 that is invalid for UTF-8.
+      #
+      # You can use `to_string_lossy` or `to_string` methods to get a raw string value.
+      #
+      # @return [String]
+      attr_reader :value
+      # Location of the string begin
+      #
+      # ```text
+      # "foo"
+      # ~
+      # ```
+      #
+      # `None` if string literal is a part of the words array (like `%w[foo bar baz]`)
+      #
+      # @return [Loc, nil]
+      attr_reader :begin_l
+      # Location of the string begin
+      #
+      # ```text
+      # "foo"
+      #     ~
+      # ```
+      #
+      # `None` if string literal is a part of the words array (like `%w[foo bar baz]`)
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # "foo"
+      # ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a `super` keyword
+    class Super < Node
+      # A list of arguments given to `super`
+      #
+      # @return [::Array<Node>]
+      attr_reader :args
+      # Location of the `super` keyword
+      #
+      # ```text
+      # super(1, 2)
+      # ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the open parenthesis
+      #
+      # ```text
+      # super(1, 2)
+      #      ~
+      # ```
+      #
+      # `None` if there are no parentheses
+      #
+      # @return [Loc, nil]
+      attr_reader :begin_l
+      # Location of the closing parenthesis
+      #
+      # ```text
+      # super(1, 2)
+      #           ~
+      # ```
+      #
+      # `None` if there are no parentheses
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # super(1, 2)
+      # ~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a plain symbol literal (i.e. `:foo`)
+    #
+    # Note that `:` in `{ foo: bar }` belongs to a `pair` node.
+    class Sym < Node
+      # Value of the symbol literal
+      #
+      # Note that it's a `StringValue`, not a `String`.
+      # The reason is that you can get UTF-8 incompatible strings
+      # from a valid UTF-8 source using escape sequences like `"\xFF"`
+      #
+      # These "\", "x", "F", "F" chars are valid separately, but together
+      # they construct a char with code = 255 that is invalid for UTF-8.
+      #
+      # You can use `to_string_lossy` or `to_string` methods to get a raw symbol value.
+      #
+      # @return [String]
+      attr_reader :name
+      # Location of the symbol begin
+      #
+      # ```text
+      # :foo
+      # ~
+      # ```
+      #
+      # `None` if symbol is a label (`{ foo: 1 }`) or a part of the symbols array (`%i[foo bar baz]`)
+      #
+      # @return [Loc, nil]
+      attr_reader :begin_l
+      # Location of the symbol end
+      #
+      # ```text
+      # { 'foo': 1 }
+      #        ~
+      # ```
+      #
+      # `None` if symbol is **not** a string label (`:foo`) or a part of the symbols array (`%i[foo bar baz]`)
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # :foo
+      # ~~~~
+      #
+      # { foo: 1 }
+      #   ~~~~
+      #
+      # %i[foo]
+      #    ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a `true` literal
+    class True < Node
+      # Location of the `true` keyword
+      #
+      # ```text
+      # true
+      # ~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents an `undef` keyword (e.g. `undef foo, :bar`)
+    class Undef < Node
+      # A list of names to `undef`
+      #
+      # @return [::Array<Node>]
+      attr_reader :names
+      # Location the `undef` keyword
+      #
+      # ```text
+      # undef foo, :bar
+      # ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the full expression
+      #
+      # ```text
+      # undef :foo, bar
+      # ~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents an `unless` guard used in pattern matching (i.e. `in pattern unless guard`)
+    class UnlessGuard < Node
+      # Condition of the guard, `Lvar("foo")` in `in pattern unless guard`
+      #
+      # @return [Node]
+      attr_reader :cond
+      # Location of the `unless` keyword
+      #
+      # ```text
+      # case foo; in pattern unless cond; end
+      #                      ~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the full expression
+      #
+      # ```text
+      # case foo; in pattern unless cond; end
+      #                      ~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents `until` loop
+    class Until < Node
+      # Condition of the loop
+      #
+      # @return [Node]
+      attr_reader :cond
+      # Body of the loop.
+      #
+      # `None` if body is empty
+      #
+      # @return [Node, nil]
+      attr_reader :body
+      # Location of the `until` keyword
+      #
+      # ```text
+      # until cond do; foo; end
+      # ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the `do` keyword
+      #
+      # ```text
+      # until cond do; foo; end
+      #            ~~
+      # ```
+      #
+      # `do` is optional, and so `begin_l` can be `None`
+      #
+      # @return [Loc, nil]
+      attr_reader :begin_l
+      # Location of the `end` keyword
+      #
+      # ```text
+      # until cond do; foo; end
+      #                     ~~~
+      # ```
+      #
+      # `None` if loop is a modifier (i.e. `foo until bar`)
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # until cond do; foo; end
+      # ~~~~~~~~~~~~~~~~~~~~~~~
+      #
+      # foo until bar
+      # ~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a post-until loop
+    #
+    # ```text
+    # begin
+    # foo
+    # end until bar
+    # ```
+    class UntilPost < Node
+      # Condition of the loop
+      #
+      # @return [Node]
+      attr_reader :cond
+      # Body of the loop
+      #
+      # @return [Node]
+      attr_reader :body
+      # Location of the `until` keyword
+      #
+      # ```text
+      # begin; foo; end until bar
+      #                 ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the `until` keyword
+      #
+      # ```text
+      # begin; foo; end until bar
+      # ~~~~~~~~~~~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a branch of the `case` statement (i.e. `when foo`)
+    class When < Node
+      # A list of values to compare/match against
+      #
+      # @return [::Array<Node>]
+      attr_reader :patterns
+      # Body of the `when` branch
+      #
+      # @return [Node, nil]
+      attr_reader :body
+      # Location of the `when` keyword
+      #
+      # ```text
+      # case foo; when bar; end
+      #           ~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the `then` keyword
+      #
+      # ```text
+      # case foo; when bar then baz; end
+      #                    ~~~~
+      # ```
+      #
+      # `then` is optional, and so `begin_l` can be `None`
+      #
+      # @return [Loc]
+      attr_reader :begin_l
+      # Location of the full expression
+      #
+      # ```text
+      # case foo; when bar then baz; end
+      #           ~~~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents `while` loop
+    class While < Node
+      # Condition of the loop
+      #
+      # @return [Node]
+      attr_reader :cond
+      # Body of the loop.
+      #
+      # `None` if body is empty
+      #
+      # @return [Node, nil]
+      attr_reader :body
+      # Location of the `while` keyword
+      #
+      # ```text
+      # while cond do; foo; end
+      # ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the `do` keyword
+      #
+      # ```text
+      # while cond do; foo; end
+      #            ~~
+      # ```
+      #
+      # `do` is optional, and so `begin_l` can be `None`
+      #
+      # @return [Loc, nil]
+      attr_reader :begin_l
+      # Location of the `end` keyword
+      #
+      # ```text
+      # while cond do; foo; end
+      #                     ~~~
+      # ```
+      #
+      # `None` if loop is a modifier (i.e. `foo while bar`)
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # while cond do; foo; end
+      # ~~~~~~~~~~~~~~~~~~~~~~~
+      #
+      # foo while bar
+      # ~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a post-while loop
+    #
+    # ```text
+    # begin
+    # foo
+    # end while bar
+    # ```
+    class WhilePost < Node
+      # Condition of the loop
+      #
+      # @return [Node]
+      attr_reader :cond
+      # Body of the loop
+      #
+      # @return [Node]
+      attr_reader :body
+      # Location of the `while` keyword
+      #
+      # ```text
+      # begin; foo; end while bar
+      #                 ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the `while` keyword
+      #
+      # ```text
+      # begin; foo; end while bar
+      # ~~~~~~~~~~~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a executable here-document literal (both with and without interpolation)
+    #
+    # It's similar to `Xstr` in terms of abstract syntax tree, but has different source maps.
+    class XHeredoc < Node
+      # A list of string parts (static literals and interpolated expressions)
+      #
+      # @return [::Array<Node>]
+      attr_reader :parts
+      # Location of the executable here-document body
+      #
+      # ```text
+      # <<-`HERE`\n  a\n   #{42}\nHERE
+      #          ~~~~~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :heredoc_body_l
+      # Location of the executable here-document end
+      #
+      # ```text
+      # <<-`HERE`\n  a\n   #{42}\nHERE
+      #                           ~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :heredoc_end_l
+      # Location of the executable here-document identifier
+      #
+      # ```text
+      # <<-`HERE`\n  a\n   #{42}\nHERE
+      # ~~~~~~~
+      # ```
+      #
+      # **Note**: This is the only node (with `Heredoc`) that has `expression_l` smaller that all other sub-locations merged.
+      # The reason for that is that it's possible to add more code after here-document ID:
+      #
+      # ```text
+      # <<-`HERE` + "rest"
+      # content
+      # HERE
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents an executable string (i.e. `` `sh #{script_name}` ``)
+    class Xstr < Node
+      # A list of string parts (static literals and interpolated expressions)
+      #
+      # @return [::Array<Node>]
+      attr_reader :parts
+      # Location of the string begin
+      #
+      # ```text
+      # `#{foo}`
+      # ~
+      #
+      # %X{#{foo}}
+      # ~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :begin_l
+      # Location of the string end
+      #
+      # ```text
+      # `#{foo}`
+      #        ~
+      #
+      # %X{#{foo}}
+      #          ~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # `#{foo}`
+      # ~~~~~~~~
+      #
+      # %X{#{foo}}
+      # ~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents an `yield` keyword
+    class Yield < Node
+      # A list of arguments given to `yield`
+      #
+      # @return [::Array<Node>]
+      attr_reader :args
+      # Location of the `yield` keyword
+      #
+      # ```text
+      # yield 1, 2
+      # ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :keyword_l
+      # Location of the open parenthesis
+      #
+      # ```text
+      # yield(1, 2)
+      #      ~
+      # ```
+      #
+      # `None` if there are no parentheses
+      #
+      # @return [Loc, nil]
+      attr_reader :begin_l
+      # Location of the closing parenthesis
+      #
+      # ```text
+      # yield(1, 2)
+      #           ~
+      # ```
+      #
+      # `None` if there are no parentheses
+      #
+      # @return [Loc, nil]
+      attr_reader :end_l
+      # Location of the full expression
+      #
+      # ```text
+      # yield(1, 2)
+      # ~~~~~~~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+    # Represents a `super` call without arguments and parentheses
+    #
+    # It's different from `super()` as it implicitly forwards current arguments
+    class ZSuper < Node
+      # Location of the `super` keyword
+      #
+      # ```text
+      # super
+      # ~~~~~
+      # ```
+      #
+      # @return [Loc]
+      attr_reader :expression_l
+    end
+
+  end
+end