RubyGems - yarp - Versions diffs - 0.7.0 → 0.8.0 - Mend

yarp 0.7.0 → 0.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (31) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +21 -2
data/Makefile +2 -0
data/README.md +5 -2
data/config.yml +54 -267
data/ext/yarp/api_node.c +135 -579
data/ext/yarp/extension.c +2 -2
data/ext/yarp/extension.h +1 -1
data/include/yarp/ast.h +142 -285
data/include/yarp/defines.h +5 -0
data/include/yarp/unescape.h +1 -1
data/include/yarp/util/yp_buffer.h +9 -1
data/include/yarp/util/yp_constant_pool.h +3 -0
data/include/yarp/util/yp_list.h +7 -7
data/include/yarp/util/yp_newline_list.h +4 -0
data/include/yarp/util/yp_state_stack.h +1 -1
data/include/yarp/version.h +2 -2
data/lib/yarp/ffi.rb +62 -47
data/lib/yarp/node.rb +504 -1399
data/lib/yarp/serialize.rb +111 -141
data/lib/yarp.rb +6 -6
data/src/node.c +70 -250
data/src/prettyprint.c +41 -185
data/src/serialize.c +35 -133
data/src/unescape.c +29 -35
data/src/util/yp_buffer.c +18 -0
data/src/util/yp_list.c +7 -16
data/src/util/yp_state_stack.c +0 -6
data/src/yarp.c +265 -670
data/yarp.gemspec +1 -1
metadata +2 -2

data/lib/yarp/node.rb CHANGED Viewed

@@ -144,6 +144,52 @@ module YARP
     end
   end
+  # Represents the use of the `&&=` operator.
+  #
+  #     target &&= value
+  #     ^^^^^^^^^^^^^^^^
+  class AndWriteNode < Node
+    # attr_reader target: Node
+    attr_reader :target
+    # attr_reader value: Node
+    attr_reader :value
+    # attr_reader operator_loc: Location
+    attr_reader :operator_loc
+    # def initialize: (target: Node, value: Node, operator_loc: Location, location: Location) -> void
+    def initialize(target, value, operator_loc, location)
+      @target = target
+      @value = value
+      @operator_loc = operator_loc
+      @location = location
+    end
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_and_write_node(self)
+    end
+    # def child_nodes: () -> Array[nil | Node]
+    def child_nodes
+      [target, value]
+    end
+    # def deconstruct: () -> Array[nil | Node]
+    alias deconstruct child_nodes
+    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+    def deconstruct_keys(keys)
+      { target: target, value: value, operator_loc: operator_loc, location: location }
+    end
+    # def operator: () -> String
+    def operator
+      operator_loc.slice
+    end
+  end
   # Represents a set of arguments to a method or a keyword.
   #
   #     return foo, bar, baz
@@ -543,8 +589,8 @@ module YARP
     # attr_reader parameters: Node?
     attr_reader :parameters
-    # attr_reader statements: Node?
-    attr_reader :statements
+    # attr_reader body: Node?
+    attr_reader :body
     # attr_reader opening_loc: Location
     attr_reader :opening_loc
@@ -552,11 +598,11 @@ module YARP
     # attr_reader closing_loc: Location
     attr_reader :closing_loc
-    # def initialize: (locals: Array[Symbol], parameters: Node?, statements: Node?, opening_loc: Location, closing_loc: Location, location: Location) -> void
-    def initialize(locals, parameters, statements, opening_loc, closing_loc, location)
+    # def initialize: (locals: Array[Symbol], parameters: Node?, body: Node?, opening_loc: Location, closing_loc: Location, location: Location) -> void
+    def initialize(locals, parameters, body, opening_loc, closing_loc, location)
       @locals = locals
       @parameters = parameters
-      @statements = statements
+      @body = body
       @opening_loc = opening_loc
       @closing_loc = closing_loc
       @location = location
@@ -569,7 +615,7 @@ module YARP
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [parameters, statements]
+      [parameters, body]
     end
     # def deconstruct: () -> Array[nil | Node]
@@ -577,7 +623,7 @@ module YARP
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { locals: locals, parameters: parameters, statements: statements, opening_loc: opening_loc, closing_loc: closing_loc, location: location }
+      { locals: locals, parameters: parameters, body: body, opening_loc: opening_loc, closing_loc: closing_loc, location: location }
     end
     # def opening: () -> String
@@ -1119,20 +1165,20 @@ module YARP
     # attr_reader superclass: Node?
     attr_reader :superclass
-    # attr_reader statements: Node?
-    attr_reader :statements
+    # attr_reader body: Node?
+    attr_reader :body
     # attr_reader end_keyword_loc: Location
     attr_reader :end_keyword_loc
-    # def initialize: (locals: Array[Symbol], class_keyword_loc: Location, constant_path: Node, inheritance_operator_loc: Location?, superclass: Node?, statements: Node?, end_keyword_loc: Location, location: Location) -> void
-    def initialize(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, statements, end_keyword_loc, location)
+    # def initialize: (locals: Array[Symbol], class_keyword_loc: Location, constant_path: Node, inheritance_operator_loc: Location?, superclass: Node?, body: Node?, end_keyword_loc: Location, location: Location) -> void
+    def initialize(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, location)
       @locals = locals
       @class_keyword_loc = class_keyword_loc
       @constant_path = constant_path
       @inheritance_operator_loc = inheritance_operator_loc
       @superclass = superclass
-      @statements = statements
+      @body = body
       @end_keyword_loc = end_keyword_loc
       @location = location
     end
@@ -1144,7 +1190,7 @@ module YARP
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [constant_path, superclass, statements]
+      [constant_path, superclass, body]
     end
     # def deconstruct: () -> Array[nil | Node]
@@ -1152,7 +1198,7 @@ module YARP
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { locals: locals, class_keyword_loc: class_keyword_loc, constant_path: constant_path, inheritance_operator_loc: inheritance_operator_loc, superclass: superclass, statements: statements, end_keyword_loc: end_keyword_loc, location: location }
+      { locals: locals, class_keyword_loc: class_keyword_loc, constant_path: constant_path, inheritance_operator_loc: inheritance_operator_loc, superclass: superclass, body: body, end_keyword_loc: end_keyword_loc, location: location }
     end
     # def class_keyword: () -> String
@@ -1171,31 +1217,60 @@ module YARP
     end
   end
-  # Represents the use of the `&&=` operator for assignment to a class variable.
+  # Represents referencing a class variable.
   #
-  #     @@target &&= value
-  #     ^^^^^^^^^^^^^^^^
-  class ClassVariableOperatorAndWriteNode < Node
+  #     @@foo
+  #     ^^^^^
+  class ClassVariableReadNode < Node
+    # def initialize: (location: Location) -> void
+    def initialize(location)
+      @location = location
+    end
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_class_variable_read_node(self)
+    end
+    # def child_nodes: () -> Array[nil | Node]
+    def child_nodes
+      []
+    end
+    # def deconstruct: () -> Array[nil | Node]
+    alias deconstruct child_nodes
+    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+    def deconstruct_keys(keys)
+      { location: location }
+    end
+  end
+  # Represents writing to a class variable.
+  #
+  #     @@foo = 1
+  #     ^^^^^^^^^
+  class ClassVariableWriteNode < Node
     # attr_reader name_loc: Location
     attr_reader :name_loc
-    # attr_reader operator_loc: Location
-    attr_reader :operator_loc
-    # attr_reader value: Node
+    # attr_reader value: Node?
     attr_reader :value
-    # def initialize: (name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(name_loc, operator_loc, value, location)
+    # attr_reader operator_loc: Location?
+    attr_reader :operator_loc
+    # def initialize: (name_loc: Location, value: Node?, operator_loc: Location?, location: Location) -> void
+    def initialize(name_loc, value, operator_loc, location)
       @name_loc = name_loc
-      @operator_loc = operator_loc
       @value = value
+      @operator_loc = operator_loc
       @location = location
     end
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_class_variable_operator_and_write_node(self)
+      visitor.visit_class_variable_write_node(self)
     end
     # def child_nodes: () -> Array[nil | Node]
@@ -1208,7 +1283,7 @@ module YARP
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
+      { name_loc: name_loc, value: value, operator_loc: operator_loc, location: location }
     end
     # def name: () -> String
@@ -1216,42 +1291,42 @@ module YARP
       name_loc.slice
     end
-    # def operator: () -> String
+    # def operator: () -> String?
     def operator
-      operator_loc.slice
+      operator_loc&.slice
     end
   end
-  # Represents the use of the `||=` operator for assignment to a class variable.
+  # Represents accessing a constant through a path of `::` operators.
   #
-  #     @@target ||= value
-  #     ^^^^^^^^^^^^^^^^^^
-  class ClassVariableOperatorOrWriteNode < Node
-    # attr_reader name_loc: Location
-    attr_reader :name_loc
+  #     Foo::Bar
+  #     ^^^^^^^^
+  class ConstantPathNode < Node
+    # attr_reader parent: Node?
+    attr_reader :parent
-    # attr_reader operator_loc: Location
-    attr_reader :operator_loc
+    # attr_reader child: Node
+    attr_reader :child
-    # attr_reader value: Node
-    attr_reader :value
+    # attr_reader delimiter_loc: Location
+    attr_reader :delimiter_loc
-    # def initialize: (name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(name_loc, operator_loc, value, location)
-      @name_loc = name_loc
-      @operator_loc = operator_loc
-      @value = value
+    # def initialize: (parent: Node?, child: Node, delimiter_loc: Location, location: Location) -> void
+    def initialize(parent, child, delimiter_loc, location)
+      @parent = parent
+      @child = child
+      @delimiter_loc = delimiter_loc
       @location = location
     end
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_class_variable_operator_or_write_node(self)
+      visitor.visit_constant_path_node(self)
     end
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [value]
+      [parent, child]
     end
     # def deconstruct: () -> Array[nil | Node]
@@ -1259,54 +1334,51 @@ module YARP
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
-    end
-    # def name: () -> String
-    def name
-      name_loc.slice
+      { parent: parent, child: child, delimiter_loc: delimiter_loc, location: location }
     end
-    # def operator: () -> String
-    def operator
-      operator_loc.slice
+    # def delimiter: () -> String
+    def delimiter
+      delimiter_loc.slice
     end
   end
-  # Represents assigning to a class variable using an operator that isn't `=`.
+  # Represents writing to a constant path.
   #
-  #     @@target += value
-  #     ^^^^^^^^^^^^^^^^^
-  class ClassVariableOperatorWriteNode < Node
-    # attr_reader name_loc: Location
-    attr_reader :name_loc
+  #     ::Foo = 1
+  #     ^^^^^^^^^
+  #
+  #     Foo::Bar = 1
+  #     ^^^^^^^^^^^^
+  #
+  #     ::Foo::Bar = 1
+  #     ^^^^^^^^^^^^^^
+  class ConstantPathWriteNode < Node
+    # attr_reader target: Node
+    attr_reader :target
-    # attr_reader operator_loc: Location
+    # attr_reader operator_loc: Location?
     attr_reader :operator_loc
-    # attr_reader value: Node
+    # attr_reader value: Node?
     attr_reader :value
-    # attr_reader operator: Symbol
-    attr_reader :operator
-    # def initialize: (name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void
-    def initialize(name_loc, operator_loc, value, operator, location)
-      @name_loc = name_loc
+    # def initialize: (target: Node, operator_loc: Location?, value: Node?, location: Location) -> void
+    def initialize(target, operator_loc, value, location)
+      @target = target
       @operator_loc = operator_loc
       @value = value
-      @operator = operator
       @location = location
     end
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_class_variable_operator_write_node(self)
+      visitor.visit_constant_path_write_node(self)
     end
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [value]
+      [target, value]
     end
     # def deconstruct: () -> Array[nil | Node]
@@ -1314,20 +1386,20 @@ module YARP
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, operator: operator, location: location }
+      { target: target, operator_loc: operator_loc, value: value, location: location }
     end
-    # def name: () -> String
-    def name
-      name_loc.slice
+    # def operator: () -> String?
+    def operator
+      operator_loc&.slice
     end
   end
-  # Represents referencing a class variable.
+  # Represents referencing a constant.
   #
-  #     @@foo
-  #     ^^^^^
-  class ClassVariableReadNode < Node
+  #     Foo
+  #     ^^^
+  class ConstantReadNode < Node
     # def initialize: (location: Location) -> void
     def initialize(location)
       @location = location
@@ -1335,7 +1407,7 @@ module YARP
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_class_variable_read_node(self)
+      visitor.visit_constant_read_node(self)
     end
     # def child_nodes: () -> Array[nil | Node]
@@ -1352,11 +1424,11 @@ module YARP
     end
   end
-  # Represents writing to a class variable.
+  # Represents writing to a constant.
   #
-  #     @@foo = 1
-  #     ^^^^^^^^^
-  class ClassVariableWriteNode < Node
+  #     Foo = 1
+  #     ^^^^^^^
+  class ConstantWriteNode < Node
     # attr_reader name_loc: Location
     attr_reader :name_loc
@@ -1376,7 +1448,7 @@ module YARP
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_class_variable_write_node(self)
+      visitor.visit_constant_write_node(self)
     end
     # def child_nodes: () -> Array[nil | Node]
@@ -1403,36 +1475,69 @@ module YARP
     end
   end
-  # Represents the use of the `&&=` operator for assignment to a constant.
+  # Represents a method definition.
   #
-  #     Target &&= value
-  #     ^^^^^^^^^^^^^^^^
-  class ConstantOperatorAndWriteNode < Node
+  #     def method
+  #     end
+  #     ^^^^^^^^^^
+  class DefNode < Node
     # attr_reader name_loc: Location
     attr_reader :name_loc
-    # attr_reader operator_loc: Location
+    # attr_reader receiver: Node?
+    attr_reader :receiver
+    # attr_reader parameters: Node?
+    attr_reader :parameters
+    # attr_reader body: Node?
+    attr_reader :body
+    # attr_reader locals: Array[Symbol]
+    attr_reader :locals
+    # attr_reader def_keyword_loc: Location
+    attr_reader :def_keyword_loc
+    # attr_reader operator_loc: Location?
     attr_reader :operator_loc
-    # attr_reader value: Node
-    attr_reader :value
+    # attr_reader lparen_loc: Location?
+    attr_reader :lparen_loc
-    # def initialize: (name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(name_loc, operator_loc, value, location)
+    # attr_reader rparen_loc: Location?
+    attr_reader :rparen_loc
+    # attr_reader equal_loc: Location?
+    attr_reader :equal_loc
+    # attr_reader end_keyword_loc: Location?
+    attr_reader :end_keyword_loc
+    # def initialize: (name_loc: Location, receiver: Node?, parameters: Node?, body: Node?, locals: Array[Symbol], def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location?, location: Location) -> void
+    def initialize(name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location)
       @name_loc = name_loc
+      @receiver = receiver
+      @parameters = parameters
+      @body = body
+      @locals = locals
+      @def_keyword_loc = def_keyword_loc
       @operator_loc = operator_loc
-      @value = value
+      @lparen_loc = lparen_loc
+      @rparen_loc = rparen_loc
+      @equal_loc = equal_loc
+      @end_keyword_loc = end_keyword_loc
       @location = location
     end
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_constant_operator_and_write_node(self)
+      visitor.visit_def_node(self)
     end
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [value]
+      [receiver, parameters, body]
     end
     # def deconstruct: () -> Array[nil | Node]
@@ -1440,507 +1545,7 @@ module YARP
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
-    end
-    # def name: () -> String
-    def name
-      name_loc.slice
-    end
-    # def operator: () -> String
-    def operator
-      operator_loc.slice
-    end
-  end
-  # Represents the use of the `||=` operator for assignment to a constant.
-  #
-  #     Target ||= value
-  #     ^^^^^^^^^^^^^^^^
-  class ConstantOperatorOrWriteNode < Node
-    # attr_reader name_loc: Location
-    attr_reader :name_loc
-    # attr_reader operator_loc: Location
-    attr_reader :operator_loc
-    # attr_reader value: Node
-    attr_reader :value
-    # def initialize: (name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(name_loc, operator_loc, value, location)
-      @name_loc = name_loc
-      @operator_loc = operator_loc
-      @value = value
-      @location = location
-    end
-    # def accept: (visitor: Visitor) -> void
-    def accept(visitor)
-      visitor.visit_constant_operator_or_write_node(self)
-    end
-    # def child_nodes: () -> Array[nil | Node]
-    def child_nodes
-      [value]
-    end
-    # def deconstruct: () -> Array[nil | Node]
-    alias deconstruct child_nodes
-    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
-    def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
-    end
-    # def name: () -> String
-    def name
-      name_loc.slice
-    end
-    # def operator: () -> String
-    def operator
-      operator_loc.slice
-    end
-  end
-  # Represents assigning to a constant using an operator that isn't `=`.
-  #
-  #     Target += value
-  #     ^^^^^^^^^^^^^^^
-  class ConstantOperatorWriteNode < Node
-    # attr_reader name_loc: Location
-    attr_reader :name_loc
-    # attr_reader operator_loc: Location
-    attr_reader :operator_loc
-    # attr_reader value: Node
-    attr_reader :value
-    # attr_reader operator: Symbol
-    attr_reader :operator
-    # def initialize: (name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void
-    def initialize(name_loc, operator_loc, value, operator, location)
-      @name_loc = name_loc
-      @operator_loc = operator_loc
-      @value = value
-      @operator = operator
-      @location = location
-    end
-    # def accept: (visitor: Visitor) -> void
-    def accept(visitor)
-      visitor.visit_constant_operator_write_node(self)
-    end
-    # def child_nodes: () -> Array[nil | Node]
-    def child_nodes
-      [value]
-    end
-    # def deconstruct: () -> Array[nil | Node]
-    alias deconstruct child_nodes
-    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
-    def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, operator: operator, location: location }
-    end
-    # def name: () -> String
-    def name
-      name_loc.slice
-    end
-  end
-  # Represents accessing a constant through a path of `::` operators.
-  #
-  #     Foo::Bar
-  #     ^^^^^^^^
-  class ConstantPathNode < Node
-    # attr_reader parent: Node?
-    attr_reader :parent
-    # attr_reader child: Node
-    attr_reader :child
-    # attr_reader delimiter_loc: Location
-    attr_reader :delimiter_loc
-    # def initialize: (parent: Node?, child: Node, delimiter_loc: Location, location: Location) -> void
-    def initialize(parent, child, delimiter_loc, location)
-      @parent = parent
-      @child = child
-      @delimiter_loc = delimiter_loc
-      @location = location
-    end
-    # def accept: (visitor: Visitor) -> void
-    def accept(visitor)
-      visitor.visit_constant_path_node(self)
-    end
-    # def child_nodes: () -> Array[nil | Node]
-    def child_nodes
-      [parent, child]
-    end
-    # def deconstruct: () -> Array[nil | Node]
-    alias deconstruct child_nodes
-    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
-    def deconstruct_keys(keys)
-      { parent: parent, child: child, delimiter_loc: delimiter_loc, location: location }
-    end
-    # def delimiter: () -> String
-    def delimiter
-      delimiter_loc.slice
-    end
-  end
-  # Represents the use of the `&&=` operator for assignment to a constant path.
-  #
-  #     Parent::Child &&= value
-  #     ^^^^^^^^^^^^^^^^^^^^^^^
-  class ConstantPathOperatorAndWriteNode < Node
-    # attr_reader target: Node
-    attr_reader :target
-    # attr_reader operator_loc: Location
-    attr_reader :operator_loc
-    # attr_reader value: Node
-    attr_reader :value
-    # def initialize: (target: Node, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(target, operator_loc, value, location)
-      @target = target
-      @operator_loc = operator_loc
-      @value = value
-      @location = location
-    end
-    # def accept: (visitor: Visitor) -> void
-    def accept(visitor)
-      visitor.visit_constant_path_operator_and_write_node(self)
-    end
-    # def child_nodes: () -> Array[nil | Node]
-    def child_nodes
-      [target, value]
-    end
-    # def deconstruct: () -> Array[nil | Node]
-    alias deconstruct child_nodes
-    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
-    def deconstruct_keys(keys)
-      { target: target, operator_loc: operator_loc, value: value, location: location }
-    end
-    # def operator: () -> String
-    def operator
-      operator_loc.slice
-    end
-  end
-  # Represents the use of the `||=` operator for assignment to a constant path.
-  #
-  #     Parent::Child ||= value
-  #     ^^^^^^^^^^^^^^^^^^^^^^^
-  class ConstantPathOperatorOrWriteNode < Node
-    # attr_reader target: Node
-    attr_reader :target
-    # attr_reader operator_loc: Location
-    attr_reader :operator_loc
-    # attr_reader value: Node
-    attr_reader :value
-    # def initialize: (target: Node, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(target, operator_loc, value, location)
-      @target = target
-      @operator_loc = operator_loc
-      @value = value
-      @location = location
-    end
-    # def accept: (visitor: Visitor) -> void
-    def accept(visitor)
-      visitor.visit_constant_path_operator_or_write_node(self)
-    end
-    # def child_nodes: () -> Array[nil | Node]
-    def child_nodes
-      [target, value]
-    end
-    # def deconstruct: () -> Array[nil | Node]
-    alias deconstruct child_nodes
-    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
-    def deconstruct_keys(keys)
-      { target: target, operator_loc: operator_loc, value: value, location: location }
-    end
-    # def operator: () -> String
-    def operator
-      operator_loc.slice
-    end
-  end
-  # Represents assigning to a constant path using an operator that isn't `=`.
-  #
-  #     Parent::Child += value
-  #     ^^^^^^^^^^^^^^^^^^^^^^
-  class ConstantPathOperatorWriteNode < Node
-    # attr_reader target: Node
-    attr_reader :target
-    # attr_reader operator_loc: Location
-    attr_reader :operator_loc
-    # attr_reader value: Node
-    attr_reader :value
-    # attr_reader operator: Symbol
-    attr_reader :operator
-    # def initialize: (target: Node, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void
-    def initialize(target, operator_loc, value, operator, location)
-      @target = target
-      @operator_loc = operator_loc
-      @value = value
-      @operator = operator
-      @location = location
-    end
-    # def accept: (visitor: Visitor) -> void
-    def accept(visitor)
-      visitor.visit_constant_path_operator_write_node(self)
-    end
-    # def child_nodes: () -> Array[nil | Node]
-    def child_nodes
-      [target, value]
-    end
-    # def deconstruct: () -> Array[nil | Node]
-    alias deconstruct child_nodes
-    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
-    def deconstruct_keys(keys)
-      { target: target, operator_loc: operator_loc, value: value, operator: operator, location: location }
-    end
-  end
-  # Represents writing to a constant path.
-  #
-  #     ::Foo = 1
-  #     ^^^^^^^^^
-  #
-  #     Foo::Bar = 1
-  #     ^^^^^^^^^^^^
-  #
-  #     ::Foo::Bar = 1
-  #     ^^^^^^^^^^^^^^
-  class ConstantPathWriteNode < Node
-    # attr_reader target: Node
-    attr_reader :target
-    # attr_reader operator_loc: Location?
-    attr_reader :operator_loc
-    # attr_reader value: Node?
-    attr_reader :value
-    # def initialize: (target: Node, operator_loc: Location?, value: Node?, location: Location) -> void
-    def initialize(target, operator_loc, value, location)
-      @target = target
-      @operator_loc = operator_loc
-      @value = value
-      @location = location
-    end
-    # def accept: (visitor: Visitor) -> void
-    def accept(visitor)
-      visitor.visit_constant_path_write_node(self)
-    end
-    # def child_nodes: () -> Array[nil | Node]
-    def child_nodes
-      [target, value]
-    end
-    # def deconstruct: () -> Array[nil | Node]
-    alias deconstruct child_nodes
-    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
-    def deconstruct_keys(keys)
-      { target: target, operator_loc: operator_loc, value: value, location: location }
-    end
-    # def operator: () -> String?
-    def operator
-      operator_loc&.slice
-    end
-  end
-  # Represents referencing a constant.
-  #
-  #     Foo
-  #     ^^^
-  class ConstantReadNode < Node
-    # def initialize: (location: Location) -> void
-    def initialize(location)
-      @location = location
-    end
-    # def accept: (visitor: Visitor) -> void
-    def accept(visitor)
-      visitor.visit_constant_read_node(self)
-    end
-    # def child_nodes: () -> Array[nil | Node]
-    def child_nodes
-      []
-    end
-    # def deconstruct: () -> Array[nil | Node]
-    alias deconstruct child_nodes
-    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
-    def deconstruct_keys(keys)
-      { location: location }
-    end
-  end
-  # Represents writing to a constant.
-  #
-  #     Foo = 1
-  #     ^^^^^^^
-  class ConstantWriteNode < Node
-    # attr_reader name_loc: Location
-    attr_reader :name_loc
-    # attr_reader value: Node?
-    attr_reader :value
-    # attr_reader operator_loc: Location?
-    attr_reader :operator_loc
-    # def initialize: (name_loc: Location, value: Node?, operator_loc: Location?, location: Location) -> void
-    def initialize(name_loc, value, operator_loc, location)
-      @name_loc = name_loc
-      @value = value
-      @operator_loc = operator_loc
-      @location = location
-    end
-    # def accept: (visitor: Visitor) -> void
-    def accept(visitor)
-      visitor.visit_constant_write_node(self)
-    end
-    # def child_nodes: () -> Array[nil | Node]
-    def child_nodes
-      [value]
-    end
-    # def deconstruct: () -> Array[nil | Node]
-    alias deconstruct child_nodes
-    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
-    def deconstruct_keys(keys)
-      { name_loc: name_loc, value: value, operator_loc: operator_loc, location: location }
-    end
-    # def name: () -> String
-    def name
-      name_loc.slice
-    end
-    # def operator: () -> String?
-    def operator
-      operator_loc&.slice
-    end
-  end
-  # Represents a method definition.
-  #
-  #     def method
-  #     end
-  #     ^^^^^^^^^^
-  class DefNode < Node
-    # attr_reader name_loc: Location
-    attr_reader :name_loc
-    # attr_reader receiver: Node?
-    attr_reader :receiver
-    # attr_reader parameters: Node?
-    attr_reader :parameters
-    # attr_reader statements: Node?
-    attr_reader :statements
-    # attr_reader locals: Array[Symbol]
-    attr_reader :locals
-    # attr_reader def_keyword_loc: Location
-    attr_reader :def_keyword_loc
-    # attr_reader operator_loc: Location?
-    attr_reader :operator_loc
-    # attr_reader lparen_loc: Location?
-    attr_reader :lparen_loc
-    # attr_reader rparen_loc: Location?
-    attr_reader :rparen_loc
-    # attr_reader equal_loc: Location?
-    attr_reader :equal_loc
-    # attr_reader end_keyword_loc: Location?
-    attr_reader :end_keyword_loc
-    # def initialize: (name_loc: Location, receiver: Node?, parameters: Node?, statements: Node?, locals: Array[Symbol], def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location?, location: Location) -> void
-    def initialize(name_loc, receiver, parameters, statements, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location)
-      @name_loc = name_loc
-      @receiver = receiver
-      @parameters = parameters
-      @statements = statements
-      @locals = locals
-      @def_keyword_loc = def_keyword_loc
-      @operator_loc = operator_loc
-      @lparen_loc = lparen_loc
-      @rparen_loc = rparen_loc
-      @equal_loc = equal_loc
-      @end_keyword_loc = end_keyword_loc
-      @location = location
-    end
-    # def accept: (visitor: Visitor) -> void
-    def accept(visitor)
-      visitor.visit_def_node(self)
-    end
-    # def child_nodes: () -> Array[nil | Node]
-    def child_nodes
-      [receiver, parameters, statements]
-    end
-    # def deconstruct: () -> Array[nil | Node]
-    alias deconstruct child_nodes
-    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
-    def deconstruct_keys(keys)
-      { name_loc: name_loc, receiver: receiver, parameters: parameters, statements: statements, locals: locals, def_keyword_loc: def_keyword_loc, operator_loc: operator_loc, lparen_loc: lparen_loc, rparen_loc: rparen_loc, equal_loc: equal_loc, end_keyword_loc: end_keyword_loc, location: location }
+      { name_loc: name_loc, receiver: receiver, parameters: parameters, body: body, locals: locals, def_keyword_loc: def_keyword_loc, operator_loc: operator_loc, lparen_loc: lparen_loc, rparen_loc: rparen_loc, equal_loc: equal_loc, end_keyword_loc: end_keyword_loc, location: location }
     end
     # def name: () -> String
@@ -2490,137 +2095,33 @@ module YARP
     def do_keyword
       do_keyword_loc&.slice
     end
-    # def end_keyword: () -> String
-    def end_keyword
-      end_keyword_loc.slice
-    end
-  end
-  # Represents forwarding all arguments to this method to another method.
-  #
-  #     def foo(...)
-  #       bar(...)
-  #       ^^^^^^^^
-  #     end
-  class ForwardingArgumentsNode < Node
-    # def initialize: (location: Location) -> void
-    def initialize(location)
-      @location = location
-    end
-    # def accept: (visitor: Visitor) -> void
-    def accept(visitor)
-      visitor.visit_forwarding_arguments_node(self)
-    end
-    # def child_nodes: () -> Array[nil | Node]
-    def child_nodes
-      []
-    end
-    # def deconstruct: () -> Array[nil | Node]
-    alias deconstruct child_nodes
-    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
-    def deconstruct_keys(keys)
-      { location: location }
-    end
-  end
-  # Represents the use of the forwarding parameter in a method, block, or lambda declaration.
-  #
-  #     def foo(...)
-  #             ^^^
-  #     end
-  class ForwardingParameterNode < Node
-    # def initialize: (location: Location) -> void
-    def initialize(location)
-      @location = location
-    end
-    # def accept: (visitor: Visitor) -> void
-    def accept(visitor)
-      visitor.visit_forwarding_parameter_node(self)
-    end
-    # def child_nodes: () -> Array[nil | Node]
-    def child_nodes
-      []
-    end
-    # def deconstruct: () -> Array[nil | Node]
-    alias deconstruct child_nodes
-    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
-    def deconstruct_keys(keys)
-      { location: location }
-    end
-  end
-  # Represents the use of the `super` keyword without parentheses or arguments.
-  #
-  #     super
-  #     ^^^^^
-  class ForwardingSuperNode < Node
-    # attr_reader block: Node?
-    attr_reader :block
-    # def initialize: (block: Node?, location: Location) -> void
-    def initialize(block, location)
-      @block = block
-      @location = location
-    end
-    # def accept: (visitor: Visitor) -> void
-    def accept(visitor)
-      visitor.visit_forwarding_super_node(self)
-    end
-    # def child_nodes: () -> Array[nil | Node]
-    def child_nodes
-      [block]
-    end
-    # def deconstruct: () -> Array[nil | Node]
-    alias deconstruct child_nodes
-    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
-    def deconstruct_keys(keys)
-      { block: block, location: location }
-    end
+    # def end_keyword: () -> String
+    def end_keyword
+      end_keyword_loc.slice
+    end
   end
-  # Represents the use of the `&&=` operator for assignment to a global variable.
+  # Represents forwarding all arguments to this method to another method.
   #
-  #     $target &&= value
-  #     ^^^^^^^^^^^^^^^^^
-  class GlobalVariableOperatorAndWriteNode < Node
-    # attr_reader name_loc: Location
-    attr_reader :name_loc
-    # attr_reader operator_loc: Location
-    attr_reader :operator_loc
-    # attr_reader value: Node
-    attr_reader :value
-    # def initialize: (name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(name_loc, operator_loc, value, location)
-      @name_loc = name_loc
-      @operator_loc = operator_loc
-      @value = value
+  #     def foo(...)
+  #       bar(...)
+  #       ^^^^^^^^
+  #     end
+  class ForwardingArgumentsNode < Node
+    # def initialize: (location: Location) -> void
+    def initialize(location)
       @location = location
     end
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_global_variable_operator_and_write_node(self)
+      visitor.visit_forwarding_arguments_node(self)
     end
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [value]
+      []
     end
     # def deconstruct: () -> Array[nil | Node]
@@ -2628,50 +2129,29 @@ module YARP
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
-    end
-    # def name: () -> String
-    def name
-      name_loc.slice
-    end
-    # def operator: () -> String
-    def operator
-      operator_loc.slice
+      { location: location }
     end
   end
-  # Represents the use of the `||=` operator for assignment to a global variable.
+  # Represents the use of the forwarding parameter in a method, block, or lambda declaration.
   #
-  #     $target ||= value
-  #     ^^^^^^^^^^^^^^^^^
-  class GlobalVariableOperatorOrWriteNode < Node
-    # attr_reader name_loc: Location
-    attr_reader :name_loc
-    # attr_reader operator_loc: Location
-    attr_reader :operator_loc
-    # attr_reader value: Node
-    attr_reader :value
-    # def initialize: (name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(name_loc, operator_loc, value, location)
-      @name_loc = name_loc
-      @operator_loc = operator_loc
-      @value = value
+  #     def foo(...)
+  #             ^^^
+  #     end
+  class ForwardingParameterNode < Node
+    # def initialize: (location: Location) -> void
+    def initialize(location)
       @location = location
     end
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_global_variable_operator_or_write_node(self)
+      visitor.visit_forwarding_parameter_node(self)
     end
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [value]
+      []
     end
     # def deconstruct: () -> Array[nil | Node]
@@ -2679,54 +2159,32 @@ module YARP
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
-    end
-    # def name: () -> String
-    def name
-      name_loc.slice
-    end
-    # def operator: () -> String
-    def operator
-      operator_loc.slice
+      { location: location }
     end
   end
-  # Represents assigning to a global variable using an operator that isn't `=`.
+  # Represents the use of the `super` keyword without parentheses or arguments.
   #
-  #     $target += value
-  #     ^^^^^^^^^^^^^^^^
-  class GlobalVariableOperatorWriteNode < Node
-    # attr_reader name_loc: Location
-    attr_reader :name_loc
-    # attr_reader operator_loc: Location
-    attr_reader :operator_loc
-    # attr_reader value: Node
-    attr_reader :value
-    # attr_reader operator: Symbol
-    attr_reader :operator
+  #     super
+  #     ^^^^^
+  class ForwardingSuperNode < Node
+    # attr_reader block: Node?
+    attr_reader :block
-    # def initialize: (name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void
-    def initialize(name_loc, operator_loc, value, operator, location)
-      @name_loc = name_loc
-      @operator_loc = operator_loc
-      @value = value
-      @operator = operator
+    # def initialize: (block: Node?, location: Location) -> void
+    def initialize(block, location)
+      @block = block
       @location = location
     end
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_global_variable_operator_write_node(self)
+      visitor.visit_forwarding_super_node(self)
     end
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [value]
+      [block]
     end
     # def deconstruct: () -> Array[nil | Node]
@@ -2734,12 +2192,7 @@ module YARP
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, operator: operator, location: location }
-    end
-    # def name: () -> String
-    def name
-      name_loc.slice
+      { block: block, location: location }
     end
   end
@@ -2956,170 +2409,31 @@ module YARP
     # attr_reader consequent: Node?
     attr_reader :consequent
-    # attr_reader end_keyword_loc: Location?
-    attr_reader :end_keyword_loc
-    # def initialize: (if_keyword_loc: Location?, predicate: Node, statements: Node?, consequent: Node?, end_keyword_loc: Location?, location: Location) -> void
-    def initialize(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location)
-      @if_keyword_loc = if_keyword_loc
-      @predicate = predicate
-      @statements = statements
-      @consequent = consequent
-      @end_keyword_loc = end_keyword_loc
-      @location = location
-    end
-    # def accept: (visitor: Visitor) -> void
-    def accept(visitor)
-      visitor.visit_if_node(self)
-    end
-    def set_newline_flag(newline_marked)
-      predicate.set_newline_flag(newline_marked)
-    end
-    # def child_nodes: () -> Array[nil | Node]
-    def child_nodes
-      [predicate, statements, consequent]
-    end
-    # def deconstruct: () -> Array[nil | Node]
-    alias deconstruct child_nodes
-    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
-    def deconstruct_keys(keys)
-      { if_keyword_loc: if_keyword_loc, predicate: predicate, statements: statements, consequent: consequent, end_keyword_loc: end_keyword_loc, location: location }
-    end
-    # def if_keyword: () -> String?
-    def if_keyword
-      if_keyword_loc&.slice
-    end
-    # def end_keyword: () -> String?
-    def end_keyword
-      end_keyword_loc&.slice
-    end
-  end
-  # Represents an imaginary number literal.
-  #
-  #     1.0i
-  #     ^^^^
-  class ImaginaryNode < Node
-    # attr_reader numeric: Node
-    attr_reader :numeric
-    # def initialize: (numeric: Node, location: Location) -> void
-    def initialize(numeric, location)
-      @numeric = numeric
-      @location = location
-    end
-    # def accept: (visitor: Visitor) -> void
-    def accept(visitor)
-      visitor.visit_imaginary_node(self)
-    end
-    # def child_nodes: () -> Array[nil | Node]
-    def child_nodes
-      [numeric]
-    end
-    # def deconstruct: () -> Array[nil | Node]
-    alias deconstruct child_nodes
-    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
-    def deconstruct_keys(keys)
-      { numeric: numeric, location: location }
-    end
-  end
-  # Represents the use of the `in` keyword in a case statement.
-  #
-  #     case a; in b then c end
-  #             ^^^^^^^^^^^
-  class InNode < Node
-    # attr_reader pattern: Node
-    attr_reader :pattern
-    # attr_reader statements: Node?
-    attr_reader :statements
-    # attr_reader in_loc: Location
-    attr_reader :in_loc
-    # attr_reader then_loc: Location?
-    attr_reader :then_loc
-    # def initialize: (pattern: Node, statements: Node?, in_loc: Location, then_loc: Location?, location: Location) -> void
-    def initialize(pattern, statements, in_loc, then_loc, location)
-      @pattern = pattern
-      @statements = statements
-      @in_loc = in_loc
-      @then_loc = then_loc
-      @location = location
-    end
-    # def accept: (visitor: Visitor) -> void
-    def accept(visitor)
-      visitor.visit_in_node(self)
-    end
-    # def child_nodes: () -> Array[nil | Node]
-    def child_nodes
-      [pattern, statements]
-    end
-    # def deconstruct: () -> Array[nil | Node]
-    alias deconstruct child_nodes
-    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
-    def deconstruct_keys(keys)
-      { pattern: pattern, statements: statements, in_loc: in_loc, then_loc: then_loc, location: location }
-    end
-    # def in: () -> String
-    def in
-      in_loc.slice
-    end
-    # def then: () -> String?
-    def then
-      then_loc&.slice
-    end
-  end
-  # Represents the use of the `&&=` operator for assignment to an instance variable.
-  #
-  #     @target &&= value
-  #     ^^^^^^^^^^^^^^^^^
-  class InstanceVariableOperatorAndWriteNode < Node
-    # attr_reader name_loc: Location
-    attr_reader :name_loc
-    # attr_reader operator_loc: Location
-    attr_reader :operator_loc
-    # attr_reader value: Node
-    attr_reader :value
+    # attr_reader end_keyword_loc: Location?
+    attr_reader :end_keyword_loc
-    # def initialize: (name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(name_loc, operator_loc, value, location)
-      @name_loc = name_loc
-      @operator_loc = operator_loc
-      @value = value
+    # def initialize: (if_keyword_loc: Location?, predicate: Node, statements: Node?, consequent: Node?, end_keyword_loc: Location?, location: Location) -> void
+    def initialize(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location)
+      @if_keyword_loc = if_keyword_loc
+      @predicate = predicate
+      @statements = statements
+      @consequent = consequent
+      @end_keyword_loc = end_keyword_loc
       @location = location
     end
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_instance_variable_operator_and_write_node(self)
+      visitor.visit_if_node(self)
+    end
+    def set_newline_flag(newline_marked)
+      predicate.set_newline_flag(newline_marked)
     end
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [value]
+      [predicate, statements, consequent]
     end
     # def deconstruct: () -> Array[nil | Node]
@@ -3127,50 +2441,42 @@ module YARP
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
+      { if_keyword_loc: if_keyword_loc, predicate: predicate, statements: statements, consequent: consequent, end_keyword_loc: end_keyword_loc, location: location }
     end
-    # def name: () -> String
-    def name
-      name_loc.slice
+    # def if_keyword: () -> String?
+    def if_keyword
+      if_keyword_loc&.slice
     end
-    # def operator: () -> String
-    def operator
-      operator_loc.slice
+    # def end_keyword: () -> String?
+    def end_keyword
+      end_keyword_loc&.slice
     end
   end
-  # Represents the use of the `||=` operator for assignment to an instance variable.
+  # Represents an imaginary number literal.
   #
-  #     @target ||= value
-  #     ^^^^^^^^^^^^^^^^^
-  class InstanceVariableOperatorOrWriteNode < Node
-    # attr_reader name_loc: Location
-    attr_reader :name_loc
-    # attr_reader operator_loc: Location
-    attr_reader :operator_loc
-    # attr_reader value: Node
-    attr_reader :value
+  #     1.0i
+  #     ^^^^
+  class ImaginaryNode < Node
+    # attr_reader numeric: Node
+    attr_reader :numeric
-    # def initialize: (name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(name_loc, operator_loc, value, location)
-      @name_loc = name_loc
-      @operator_loc = operator_loc
-      @value = value
+    # def initialize: (numeric: Node, location: Location) -> void
+    def initialize(numeric, location)
+      @numeric = numeric
       @location = location
     end
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_instance_variable_operator_or_write_node(self)
+      visitor.visit_imaginary_node(self)
     end
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [value]
+      [numeric]
     end
     # def deconstruct: () -> Array[nil | Node]
@@ -3178,54 +2484,44 @@ module YARP
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
-    end
-    # def name: () -> String
-    def name
-      name_loc.slice
-    end
-    # def operator: () -> String
-    def operator
-      operator_loc.slice
+      { numeric: numeric, location: location }
     end
   end
-  # Represents assigning to an instance variable using an operator that isn't `=`.
+  # Represents the use of the `in` keyword in a case statement.
   #
-  #     @target += value
-  #     ^^^^^^^^^^^^^^^^
-  class InstanceVariableOperatorWriteNode < Node
-    # attr_reader name_loc: Location
-    attr_reader :name_loc
+  #     case a; in b then c end
+  #             ^^^^^^^^^^^
+  class InNode < Node
+    # attr_reader pattern: Node
+    attr_reader :pattern
-    # attr_reader operator_loc: Location
-    attr_reader :operator_loc
+    # attr_reader statements: Node?
+    attr_reader :statements
-    # attr_reader value: Node
-    attr_reader :value
+    # attr_reader in_loc: Location
+    attr_reader :in_loc
-    # attr_reader operator: Symbol
-    attr_reader :operator
+    # attr_reader then_loc: Location?
+    attr_reader :then_loc
-    # def initialize: (name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void
-    def initialize(name_loc, operator_loc, value, operator, location)
-      @name_loc = name_loc
-      @operator_loc = operator_loc
-      @value = value
-      @operator = operator
+    # def initialize: (pattern: Node, statements: Node?, in_loc: Location, then_loc: Location?, location: Location) -> void
+    def initialize(pattern, statements, in_loc, then_loc, location)
+      @pattern = pattern
+      @statements = statements
+      @in_loc = in_loc
+      @then_loc = then_loc
       @location = location
     end
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_instance_variable_operator_write_node(self)
+      visitor.visit_in_node(self)
     end
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [value]
+      [pattern, statements]
     end
     # def deconstruct: () -> Array[nil | Node]
@@ -3233,12 +2529,17 @@ module YARP
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, operator: operator, location: location }
+      { pattern: pattern, statements: statements, in_loc: in_loc, then_loc: then_loc, location: location }
     end
-    # def name: () -> String
-    def name
-      name_loc.slice
+    # def in: () -> String
+    def in
+      in_loc.slice
+    end
+    # def then: () -> String?
+    def then
+      then_loc&.slice
     end
   end
@@ -3690,202 +2991,42 @@ module YARP
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, value: value, location: location }
-    end
-    # def name: () -> String
-    def name
-      name_loc.slice
-    end
-  end
-  # Represents a keyword rest parameter to a method, block, or lambda definition.
-  #
-  #     def a(**b)
-  #           ^^^
-  #     end
-  class KeywordRestParameterNode < Node
-    # attr_reader operator_loc: Location
-    attr_reader :operator_loc
-    # attr_reader name_loc: Location?
-    attr_reader :name_loc
-    # def initialize: (operator_loc: Location, name_loc: Location?, location: Location) -> void
-    def initialize(operator_loc, name_loc, location)
-      @operator_loc = operator_loc
-      @name_loc = name_loc
-      @location = location
-    end
-    # def accept: (visitor: Visitor) -> void
-    def accept(visitor)
-      visitor.visit_keyword_rest_parameter_node(self)
-    end
-    # def child_nodes: () -> Array[nil | Node]
-    def child_nodes
-      []
-    end
-    # def deconstruct: () -> Array[nil | Node]
-    alias deconstruct child_nodes
-    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
-    def deconstruct_keys(keys)
-      { operator_loc: operator_loc, name_loc: name_loc, location: location }
-    end
-    # def operator: () -> String
-    def operator
-      operator_loc.slice
-    end
-    # def name: () -> String?
-    def name
-      name_loc&.slice
-    end
-  end
-  # Represents using a lambda literal (not the lambda method call).
-  #
-  #     ->(value) { value * 2 }
-  #     ^^^^^^^^^^^^^^^^^^^^^^^
-  class LambdaNode < Node
-    # attr_reader locals: Array[Symbol]
-    attr_reader :locals
-    # attr_reader opening_loc: Location
-    attr_reader :opening_loc
-    # attr_reader parameters: Node?
-    attr_reader :parameters
-    # attr_reader statements: Node?
-    attr_reader :statements
-    # def initialize: (locals: Array[Symbol], opening_loc: Location, parameters: Node?, statements: Node?, location: Location) -> void
-    def initialize(locals, opening_loc, parameters, statements, location)
-      @locals = locals
-      @opening_loc = opening_loc
-      @parameters = parameters
-      @statements = statements
-      @location = location
-    end
-    # def accept: (visitor: Visitor) -> void
-    def accept(visitor)
-      visitor.visit_lambda_node(self)
-    end
-    # def child_nodes: () -> Array[nil | Node]
-    def child_nodes
-      [parameters, statements]
-    end
-    # def deconstruct: () -> Array[nil | Node]
-    alias deconstruct child_nodes
-    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
-    def deconstruct_keys(keys)
-      { locals: locals, opening_loc: opening_loc, parameters: parameters, statements: statements, location: location }
-    end
-    # def opening: () -> String
-    def opening
-      opening_loc.slice
-    end
-  end
-  # Represents the use of the `&&=` operator for assignment to a local variable.
-  #
-  #     target &&= value
-  #     ^^^^^^^^^^^^^^^^
-  class LocalVariableOperatorAndWriteNode < Node
-    # attr_reader name_loc: Location
-    attr_reader :name_loc
-    # attr_reader operator_loc: Location
-    attr_reader :operator_loc
-    # attr_reader value: Node
-    attr_reader :value
-    # attr_reader constant_id: Symbol
-    attr_reader :constant_id
-    # def initialize: (name_loc: Location, operator_loc: Location, value: Node, constant_id: Symbol, location: Location) -> void
-    def initialize(name_loc, operator_loc, value, constant_id, location)
-      @name_loc = name_loc
-      @operator_loc = operator_loc
-      @value = value
-      @constant_id = constant_id
-      @location = location
-    end
-    # def accept: (visitor: Visitor) -> void
-    def accept(visitor)
-      visitor.visit_local_variable_operator_and_write_node(self)
-    end
-    # def child_nodes: () -> Array[nil | Node]
-    def child_nodes
-      [value]
-    end
-    # def deconstruct: () -> Array[nil | Node]
-    alias deconstruct child_nodes
-    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
-    def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, constant_id: constant_id, location: location }
+      { name_loc: name_loc, value: value, location: location }
     end
     # def name: () -> String
     def name
       name_loc.slice
     end
-    # def operator: () -> String
-    def operator
-      operator_loc.slice
-    end
   end
-  # Represents the use of the `||=` operator for assignment to a local variable.
+  # Represents a keyword rest parameter to a method, block, or lambda definition.
   #
-  #     target ||= value
-  #     ^^^^^^^^^^^^^^^^
-  class LocalVariableOperatorOrWriteNode < Node
-    # attr_reader name_loc: Location
-    attr_reader :name_loc
+  #     def a(**b)
+  #           ^^^
+  #     end
+  class KeywordRestParameterNode < Node
     # attr_reader operator_loc: Location
     attr_reader :operator_loc
-    # attr_reader value: Node
-    attr_reader :value
-    # attr_reader constant_id: Symbol
-    attr_reader :constant_id
+    # attr_reader name_loc: Location?
+    attr_reader :name_loc
-    # def initialize: (name_loc: Location, operator_loc: Location, value: Node, constant_id: Symbol, location: Location) -> void
-    def initialize(name_loc, operator_loc, value, constant_id, location)
-      @name_loc = name_loc
+    # def initialize: (operator_loc: Location, name_loc: Location?, location: Location) -> void
+    def initialize(operator_loc, name_loc, location)
       @operator_loc = operator_loc
-      @value = value
-      @constant_id = constant_id
+      @name_loc = name_loc
       @location = location
     end
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_local_variable_operator_or_write_node(self)
+      visitor.visit_keyword_rest_parameter_node(self)
     end
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [value]
+      []
     end
     # def deconstruct: () -> Array[nil | Node]
@@ -3893,58 +3034,54 @@ module YARP
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, constant_id: constant_id, location: location }
-    end
-    # def name: () -> String
-    def name
-      name_loc.slice
+      { operator_loc: operator_loc, name_loc: name_loc, location: location }
     end
     # def operator: () -> String
     def operator
       operator_loc.slice
     end
+    # def name: () -> String?
+    def name
+      name_loc&.slice
+    end
   end
-  # Represents assigning to a local variable using an operator that isn't `=`.
+  # Represents using a lambda literal (not the lambda method call).
   #
-  #     target += value
-  #     ^^^^^^^^^^^^^^^
-  class LocalVariableOperatorWriteNode < Node
-    # attr_reader name_loc: Location
-    attr_reader :name_loc
-    # attr_reader operator_loc: Location
-    attr_reader :operator_loc
+  #     ->(value) { value * 2 }
+  #     ^^^^^^^^^^^^^^^^^^^^^^^
+  class LambdaNode < Node
+    # attr_reader locals: Array[Symbol]
+    attr_reader :locals
-    # attr_reader value: Node
-    attr_reader :value
+    # attr_reader opening_loc: Location
+    attr_reader :opening_loc
-    # attr_reader constant_id: Symbol
-    attr_reader :constant_id
+    # attr_reader parameters: Node?
+    attr_reader :parameters
-    # attr_reader operator_id: Symbol
-    attr_reader :operator_id
+    # attr_reader body: Node?
+    attr_reader :body
-    # def initialize: (name_loc: Location, operator_loc: Location, value: Node, constant_id: Symbol, operator_id: Symbol, location: Location) -> void
-    def initialize(name_loc, operator_loc, value, constant_id, operator_id, location)
-      @name_loc = name_loc
-      @operator_loc = operator_loc
-      @value = value
-      @constant_id = constant_id
-      @operator_id = operator_id
+    # def initialize: (locals: Array[Symbol], opening_loc: Location, parameters: Node?, body: Node?, location: Location) -> void
+    def initialize(locals, opening_loc, parameters, body, location)
+      @locals = locals
+      @opening_loc = opening_loc
+      @parameters = parameters
+      @body = body
       @location = location
     end
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_local_variable_operator_write_node(self)
+      visitor.visit_lambda_node(self)
     end
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [value]
+      [parameters, body]
     end
     # def deconstruct: () -> Array[nil | Node]
@@ -3952,17 +3089,12 @@ module YARP
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, constant_id: constant_id, operator_id: operator_id, location: location }
-    end
-    # def name: () -> String
-    def name
-      name_loc.slice
+      { locals: locals, opening_loc: opening_loc, parameters: parameters, body: body, location: location }
     end
-    # def operator: () -> String
-    def operator
-      operator_loc.slice
+    # def opening: () -> String
+    def opening
+      opening_loc.slice
     end
   end
@@ -4197,18 +3329,18 @@ module YARP
     # attr_reader constant_path: Node
     attr_reader :constant_path
-    # attr_reader statements: Node?
-    attr_reader :statements
+    # attr_reader body: Node?
+    attr_reader :body
     # attr_reader end_keyword_loc: Location
     attr_reader :end_keyword_loc
-    # def initialize: (locals: Array[Symbol], module_keyword_loc: Location, constant_path: Node, statements: Node?, end_keyword_loc: Location, location: Location) -> void
-    def initialize(locals, module_keyword_loc, constant_path, statements, end_keyword_loc, location)
+    # def initialize: (locals: Array[Symbol], module_keyword_loc: Location, constant_path: Node, body: Node?, end_keyword_loc: Location, location: Location) -> void
+    def initialize(locals, module_keyword_loc, constant_path, body, end_keyword_loc, location)
       @locals = locals
       @module_keyword_loc = module_keyword_loc
       @constant_path = constant_path
-      @statements = statements
+      @body = body
       @end_keyword_loc = end_keyword_loc
       @location = location
     end
@@ -4220,7 +3352,7 @@ module YARP
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [constant_path, statements]
+      [constant_path, body]
     end
     # def deconstruct: () -> Array[nil | Node]
@@ -4228,7 +3360,7 @@ module YARP
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { locals: locals, module_keyword_loc: module_keyword_loc, constant_path: constant_path, statements: statements, end_keyword_loc: end_keyword_loc, location: location }
+      { locals: locals, module_keyword_loc: module_keyword_loc, constant_path: constant_path, body: body, end_keyword_loc: end_keyword_loc, location: location }
     end
     # def module_keyword: () -> String
@@ -4454,6 +3586,51 @@ module YARP
     end
   end
+  # Represents the use of an operator on a write.
+  #
+  #     target += value
+  #     ^^^^^^^^^^^^^^^
+  class OperatorWriteNode < Node
+    # attr_reader target: Node
+    attr_reader :target
+    # attr_reader operator_loc: Location
+    attr_reader :operator_loc
+    # attr_reader operator: Symbol
+    attr_reader :operator
+    # attr_reader value: Node
+    attr_reader :value
+    # def initialize: (target: Node, operator_loc: Location, operator: Symbol, value: Node, location: Location) -> void
+    def initialize(target, operator_loc, operator, value, location)
+      @target = target
+      @operator_loc = operator_loc
+      @operator = operator
+      @value = value
+      @location = location
+    end
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_operator_write_node(self)
+    end
+    # def child_nodes: () -> Array[nil | Node]
+    def child_nodes
+      [target, value]
+    end
+    # def deconstruct: () -> Array[nil | Node]
+    alias deconstruct child_nodes
+    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+    def deconstruct_keys(keys)
+      { target: target, operator_loc: operator_loc, operator: operator, value: value, location: location }
+    end
+  end
   # Represents an optional parameter to a method, block, or lambda definition.
   #
   #     def a(b = 1)
@@ -4556,6 +3733,52 @@ module YARP
     end
   end
+  # Represents the use of the `||=` operator.
+  #
+  #     target ||= value
+  #     ^^^^^^^^^^^^^^^^
+  class OrWriteNode < Node
+    # attr_reader target: Node
+    attr_reader :target
+    # attr_reader value: Node
+    attr_reader :value
+    # attr_reader operator_loc: Location
+    attr_reader :operator_loc
+    # def initialize: (target: Node, value: Node, operator_loc: Location, location: Location) -> void
+    def initialize(target, value, operator_loc, location)
+      @target = target
+      @value = value
+      @operator_loc = operator_loc
+      @location = location
+    end
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_or_write_node(self)
+    end
+    # def child_nodes: () -> Array[nil | Node]
+    def child_nodes
+      [target, value]
+    end
+    # def deconstruct: () -> Array[nil | Node]
+    alias deconstruct child_nodes
+    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+    def deconstruct_keys(keys)
+      { target: target, value: value, operator_loc: operator_loc, location: location }
+    end
+    # def operator: () -> String
+    def operator
+      operator_loc.slice
+    end
+  end
   # Represents the list of parameters on a method, block, or lambda definition.
   #
   #     def a(b, c, d)
@@ -4619,8 +3842,8 @@ module YARP
   #     (10 + 34)
   #     ^^^^^^^^^
   class ParenthesesNode < Node
-    # attr_reader statements: Node?
-    attr_reader :statements
+    # attr_reader body: Node?
+    attr_reader :body
     # attr_reader opening_loc: Location
     attr_reader :opening_loc
@@ -4628,9 +3851,9 @@ module YARP
     # attr_reader closing_loc: Location
     attr_reader :closing_loc
-    # def initialize: (statements: Node?, opening_loc: Location, closing_loc: Location, location: Location) -> void
-    def initialize(statements, opening_loc, closing_loc, location)
-      @statements = statements
+    # def initialize: (body: Node?, opening_loc: Location, closing_loc: Location, location: Location) -> void
+    def initialize(body, opening_loc, closing_loc, location)
+      @body = body
       @opening_loc = opening_loc
       @closing_loc = closing_loc
       @location = location
@@ -4647,7 +3870,7 @@ module YARP
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [statements]
+      [body]
     end
     # def deconstruct: () -> Array[nil | Node]
@@ -4655,7 +3878,7 @@ module YARP
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { statements: statements, opening_loc: opening_loc, closing_loc: closing_loc, location: location }
+      { body: body, opening_loc: opening_loc, closing_loc: closing_loc, location: location }
     end
     # def opening: () -> String
@@ -5521,19 +4744,19 @@ module YARP
     # attr_reader expression: Node
     attr_reader :expression
-    # attr_reader statements: Node?
-    attr_reader :statements
+    # attr_reader body: Node?
+    attr_reader :body
     # attr_reader end_keyword_loc: Location
     attr_reader :end_keyword_loc
-    # def initialize: (locals: Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Node, statements: Node?, end_keyword_loc: Location, location: Location) -> void
-    def initialize(locals, class_keyword_loc, operator_loc, expression, statements, end_keyword_loc, location)
+    # def initialize: (locals: Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Node, body: Node?, end_keyword_loc: Location, location: Location) -> void
+    def initialize(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location)
       @locals = locals
       @class_keyword_loc = class_keyword_loc
       @operator_loc = operator_loc
       @expression = expression
-      @statements = statements
+      @body = body
       @end_keyword_loc = end_keyword_loc
       @location = location
     end
@@ -5545,7 +4768,7 @@ module YARP
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [expression, statements]
+      [expression, body]
     end
     # def deconstruct: () -> Array[nil | Node]
@@ -5553,7 +4776,7 @@ module YARP
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { locals: locals, class_keyword_loc: class_keyword_loc, operator_loc: operator_loc, expression: expression, statements: statements, end_keyword_loc: end_keyword_loc, location: location }
+      { locals: locals, class_keyword_loc: class_keyword_loc, operator_loc: operator_loc, expression: expression, body: body, end_keyword_loc: end_keyword_loc, location: location }
     end
     # def class_keyword: () -> String
@@ -6171,10 +5394,12 @@ module YARP
     end
   end
-  # case true
-  # when true
-  # ^^^^^^^^^
-  # end
+  # Represents the use of the `when` keyword within a case statement.
+  #
+  #     case true
+  #     when true
+  #     ^^^^^^^^^
+  #     end
   class WhenNode < Node
     # attr_reader keyword_loc: Location
     attr_reader :keyword_loc
@@ -6453,6 +5678,9 @@ module YARP
     # Visit a AndNode node
     alias visit_and_node visit_child_nodes
+    # Visit a AndWriteNode node
+    alias visit_and_write_node visit_child_nodes
     # Visit a ArgumentsNode node
     alias visit_arguments_node visit_child_nodes
@@ -6510,42 +5738,15 @@ module YARP
     # Visit a ClassNode node
     alias visit_class_node visit_child_nodes
-    # Visit a ClassVariableOperatorAndWriteNode node
-    alias visit_class_variable_operator_and_write_node visit_child_nodes
-    # Visit a ClassVariableOperatorOrWriteNode node
-    alias visit_class_variable_operator_or_write_node visit_child_nodes
-    # Visit a ClassVariableOperatorWriteNode node
-    alias visit_class_variable_operator_write_node visit_child_nodes
     # Visit a ClassVariableReadNode node
     alias visit_class_variable_read_node visit_child_nodes
     # Visit a ClassVariableWriteNode node
     alias visit_class_variable_write_node visit_child_nodes
-    # Visit a ConstantOperatorAndWriteNode node
-    alias visit_constant_operator_and_write_node visit_child_nodes
-    # Visit a ConstantOperatorOrWriteNode node
-    alias visit_constant_operator_or_write_node visit_child_nodes
-    # Visit a ConstantOperatorWriteNode node
-    alias visit_constant_operator_write_node visit_child_nodes
     # Visit a ConstantPathNode node
     alias visit_constant_path_node visit_child_nodes
-    # Visit a ConstantPathOperatorAndWriteNode node
-    alias visit_constant_path_operator_and_write_node visit_child_nodes
-    # Visit a ConstantPathOperatorOrWriteNode node
-    alias visit_constant_path_operator_or_write_node visit_child_nodes
-    # Visit a ConstantPathOperatorWriteNode node
-    alias visit_constant_path_operator_write_node visit_child_nodes
     # Visit a ConstantPathWriteNode node
     alias visit_constant_path_write_node visit_child_nodes
@@ -6597,15 +5798,6 @@ module YARP
     # Visit a ForwardingSuperNode node
     alias visit_forwarding_super_node visit_child_nodes
-    # Visit a GlobalVariableOperatorAndWriteNode node
-    alias visit_global_variable_operator_and_write_node visit_child_nodes
-    # Visit a GlobalVariableOperatorOrWriteNode node
-    alias visit_global_variable_operator_or_write_node visit_child_nodes
-    # Visit a GlobalVariableOperatorWriteNode node
-    alias visit_global_variable_operator_write_node visit_child_nodes
     # Visit a GlobalVariableReadNode node
     alias visit_global_variable_read_node visit_child_nodes
@@ -6627,15 +5819,6 @@ module YARP
     # Visit a InNode node
     alias visit_in_node visit_child_nodes
-    # Visit a InstanceVariableOperatorAndWriteNode node
-    alias visit_instance_variable_operator_and_write_node visit_child_nodes
-    # Visit a InstanceVariableOperatorOrWriteNode node
-    alias visit_instance_variable_operator_or_write_node visit_child_nodes
-    # Visit a InstanceVariableOperatorWriteNode node
-    alias visit_instance_variable_operator_write_node visit_child_nodes
     # Visit a InstanceVariableReadNode node
     alias visit_instance_variable_read_node visit_child_nodes
@@ -6669,15 +5852,6 @@ module YARP
     # Visit a LambdaNode node
     alias visit_lambda_node visit_child_nodes
-    # Visit a LocalVariableOperatorAndWriteNode node
-    alias visit_local_variable_operator_and_write_node visit_child_nodes
-    # Visit a LocalVariableOperatorOrWriteNode node
-    alias visit_local_variable_operator_or_write_node visit_child_nodes
-    # Visit a LocalVariableOperatorWriteNode node
-    alias visit_local_variable_operator_write_node visit_child_nodes
     # Visit a LocalVariableReadNode node
     alias visit_local_variable_read_node visit_child_nodes
@@ -6711,12 +5885,18 @@ module YARP
     # Visit a NumberedReferenceReadNode node
     alias visit_numbered_reference_read_node visit_child_nodes
+    # Visit a OperatorWriteNode node
+    alias visit_operator_write_node visit_child_nodes
     # Visit a OptionalParameterNode node
     alias visit_optional_parameter_node visit_child_nodes
     # Visit a OrNode node
     alias visit_or_node visit_child_nodes
+    # Visit a OrWriteNode node
+    alias visit_or_write_node visit_child_nodes
     # Visit a ParametersNode node
     alias visit_parameters_node visit_child_nodes
@@ -6852,6 +6032,11 @@ module YARP
       AndNode.new(left, right, operator_loc, location)
     end
+    # Create a new AndWriteNode node
+    def AndWriteNode(target, value, operator_loc, location = Location())
+      AndWriteNode.new(target, value, operator_loc, location)
+    end
     # Create a new ArgumentsNode node
     def ArgumentsNode(arguments, location = Location())
       ArgumentsNode.new(arguments, location)
@@ -6893,8 +6078,8 @@ module YARP
     end
     # Create a new BlockNode node
-    def BlockNode(locals, parameters, statements, opening_loc, closing_loc, location = Location())
-      BlockNode.new(locals, parameters, statements, opening_loc, closing_loc, location)
+    def BlockNode(locals, parameters, body, opening_loc, closing_loc, location = Location())
+      BlockNode.new(locals, parameters, body, opening_loc, closing_loc, location)
     end
     # Create a new BlockParameterNode node
@@ -6943,23 +6128,8 @@ module YARP
     end
     # Create a new ClassNode node
-    def ClassNode(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, statements, end_keyword_loc, location = Location())
-      ClassNode.new(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, statements, end_keyword_loc, location)
-    end
-    # Create a new ClassVariableOperatorAndWriteNode node
-    def ClassVariableOperatorAndWriteNode(name_loc, operator_loc, value, location = Location())
-      ClassVariableOperatorAndWriteNode.new(name_loc, operator_loc, value, location)
-    end
-    # Create a new ClassVariableOperatorOrWriteNode node
-    def ClassVariableOperatorOrWriteNode(name_loc, operator_loc, value, location = Location())
-      ClassVariableOperatorOrWriteNode.new(name_loc, operator_loc, value, location)
-    end
-    # Create a new ClassVariableOperatorWriteNode node
-    def ClassVariableOperatorWriteNode(name_loc, operator_loc, value, operator, location = Location())
-      ClassVariableOperatorWriteNode.new(name_loc, operator_loc, value, operator, location)
+    def ClassNode(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, location = Location())
+      ClassNode.new(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, location)
     end
     # Create a new ClassVariableReadNode node
@@ -6972,41 +6142,11 @@ module YARP
       ClassVariableWriteNode.new(name_loc, value, operator_loc, location)
     end
-    # Create a new ConstantOperatorAndWriteNode node
-    def ConstantOperatorAndWriteNode(name_loc, operator_loc, value, location = Location())
-      ConstantOperatorAndWriteNode.new(name_loc, operator_loc, value, location)
-    end
-    # Create a new ConstantOperatorOrWriteNode node
-    def ConstantOperatorOrWriteNode(name_loc, operator_loc, value, location = Location())
-      ConstantOperatorOrWriteNode.new(name_loc, operator_loc, value, location)
-    end
-    # Create a new ConstantOperatorWriteNode node
-    def ConstantOperatorWriteNode(name_loc, operator_loc, value, operator, location = Location())
-      ConstantOperatorWriteNode.new(name_loc, operator_loc, value, operator, location)
-    end
     # Create a new ConstantPathNode node
     def ConstantPathNode(parent, child, delimiter_loc, location = Location())
       ConstantPathNode.new(parent, child, delimiter_loc, location)
     end
-    # Create a new ConstantPathOperatorAndWriteNode node
-    def ConstantPathOperatorAndWriteNode(target, operator_loc, value, location = Location())
-      ConstantPathOperatorAndWriteNode.new(target, operator_loc, value, location)
-    end
-    # Create a new ConstantPathOperatorOrWriteNode node
-    def ConstantPathOperatorOrWriteNode(target, operator_loc, value, location = Location())
-      ConstantPathOperatorOrWriteNode.new(target, operator_loc, value, location)
-    end
-    # Create a new ConstantPathOperatorWriteNode node
-    def ConstantPathOperatorWriteNode(target, operator_loc, value, operator, location = Location())
-      ConstantPathOperatorWriteNode.new(target, operator_loc, value, operator, location)
-    end
     # Create a new ConstantPathWriteNode node
     def ConstantPathWriteNode(target, operator_loc, value, location = Location())
       ConstantPathWriteNode.new(target, operator_loc, value, location)
@@ -7023,8 +6163,8 @@ module YARP
     end
     # Create a new DefNode node
-    def DefNode(name_loc, receiver, parameters, statements, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location = Location())
-      DefNode.new(name_loc, receiver, parameters, statements, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location)
+    def DefNode(name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location = Location())
+      DefNode.new(name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location)
     end
     # Create a new DefinedNode node
@@ -7092,21 +6232,6 @@ module YARP
       ForwardingSuperNode.new(block, location)
     end
-    # Create a new GlobalVariableOperatorAndWriteNode node
-    def GlobalVariableOperatorAndWriteNode(name_loc, operator_loc, value, location = Location())
-      GlobalVariableOperatorAndWriteNode.new(name_loc, operator_loc, value, location)
-    end
-    # Create a new GlobalVariableOperatorOrWriteNode node
-    def GlobalVariableOperatorOrWriteNode(name_loc, operator_loc, value, location = Location())
-      GlobalVariableOperatorOrWriteNode.new(name_loc, operator_loc, value, location)
-    end
-    # Create a new GlobalVariableOperatorWriteNode node
-    def GlobalVariableOperatorWriteNode(name_loc, operator_loc, value, operator, location = Location())
-      GlobalVariableOperatorWriteNode.new(name_loc, operator_loc, value, operator, location)
-    end
     # Create a new GlobalVariableReadNode node
     def GlobalVariableReadNode(location = Location())
       GlobalVariableReadNode.new(location)
@@ -7142,21 +6267,6 @@ module YARP
       InNode.new(pattern, statements, in_loc, then_loc, location)
     end
-    # Create a new InstanceVariableOperatorAndWriteNode node
-    def InstanceVariableOperatorAndWriteNode(name_loc, operator_loc, value, location = Location())
-      InstanceVariableOperatorAndWriteNode.new(name_loc, operator_loc, value, location)
-    end
-    # Create a new InstanceVariableOperatorOrWriteNode node
-    def InstanceVariableOperatorOrWriteNode(name_loc, operator_loc, value, location = Location())
-      InstanceVariableOperatorOrWriteNode.new(name_loc, operator_loc, value, location)
-    end
-    # Create a new InstanceVariableOperatorWriteNode node
-    def InstanceVariableOperatorWriteNode(name_loc, operator_loc, value, operator, location = Location())
-      InstanceVariableOperatorWriteNode.new(name_loc, operator_loc, value, operator, location)
-    end
     # Create a new InstanceVariableReadNode node
     def InstanceVariableReadNode(location = Location())
       InstanceVariableReadNode.new(location)
@@ -7208,23 +6318,8 @@ module YARP
     end
     # Create a new LambdaNode node
-    def LambdaNode(locals, opening_loc, parameters, statements, location = Location())
-      LambdaNode.new(locals, opening_loc, parameters, statements, location)
-    end
-    # Create a new LocalVariableOperatorAndWriteNode node
-    def LocalVariableOperatorAndWriteNode(name_loc, operator_loc, value, constant_id, location = Location())
-      LocalVariableOperatorAndWriteNode.new(name_loc, operator_loc, value, constant_id, location)
-    end
-    # Create a new LocalVariableOperatorOrWriteNode node
-    def LocalVariableOperatorOrWriteNode(name_loc, operator_loc, value, constant_id, location = Location())
-      LocalVariableOperatorOrWriteNode.new(name_loc, operator_loc, value, constant_id, location)
-    end
-    # Create a new LocalVariableOperatorWriteNode node
-    def LocalVariableOperatorWriteNode(name_loc, operator_loc, value, constant_id, operator_id, location = Location())
-      LocalVariableOperatorWriteNode.new(name_loc, operator_loc, value, constant_id, operator_id, location)
+    def LambdaNode(locals, opening_loc, parameters, body, location = Location())
+      LambdaNode.new(locals, opening_loc, parameters, body, location)
     end
     # Create a new LocalVariableReadNode node
@@ -7253,8 +6348,8 @@ module YARP
     end
     # Create a new ModuleNode node
-    def ModuleNode(locals, module_keyword_loc, constant_path, statements, end_keyword_loc, location = Location())
-      ModuleNode.new(locals, module_keyword_loc, constant_path, statements, end_keyword_loc, location)
+    def ModuleNode(locals, module_keyword_loc, constant_path, body, end_keyword_loc, location = Location())
+      ModuleNode.new(locals, module_keyword_loc, constant_path, body, end_keyword_loc, location)
     end
     # Create a new MultiWriteNode node
@@ -7282,6 +6377,11 @@ module YARP
       NumberedReferenceReadNode.new(location)
     end
+    # Create a new OperatorWriteNode node
+    def OperatorWriteNode(target, operator_loc, operator, value, location = Location())
+      OperatorWriteNode.new(target, operator_loc, operator, value, location)
+    end
     # Create a new OptionalParameterNode node
     def OptionalParameterNode(constant_id, name_loc, operator_loc, value, location = Location())
       OptionalParameterNode.new(constant_id, name_loc, operator_loc, value, location)
@@ -7292,14 +6392,19 @@ module YARP
       OrNode.new(left, right, operator_loc, location)
     end
+    # Create a new OrWriteNode node
+    def OrWriteNode(target, value, operator_loc, location = Location())
+      OrWriteNode.new(target, value, operator_loc, location)
+    end
     # Create a new ParametersNode node
     def ParametersNode(requireds, optionals, posts, rest, keywords, keyword_rest, block, location = Location())
       ParametersNode.new(requireds, optionals, posts, rest, keywords, keyword_rest, block, location)
     end
     # Create a new ParenthesesNode node
-    def ParenthesesNode(statements, opening_loc, closing_loc, location = Location())
-      ParenthesesNode.new(statements, opening_loc, closing_loc, location)
+    def ParenthesesNode(body, opening_loc, closing_loc, location = Location())
+      ParenthesesNode.new(body, opening_loc, closing_loc, location)
     end
     # Create a new PinnedExpressionNode node
@@ -7388,8 +6493,8 @@ module YARP
     end
     # Create a new SingletonClassNode node
-    def SingletonClassNode(locals, class_keyword_loc, operator_loc, expression, statements, end_keyword_loc, location = Location())
-      SingletonClassNode.new(locals, class_keyword_loc, operator_loc, expression, statements, end_keyword_loc, location)
+    def SingletonClassNode(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location = Location())
+      SingletonClassNode.new(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location)
     end
     # Create a new SourceEncodingNode node