yarp 0.7.0 → 0.8.0

data/lib/yarp/node.rb

@@ -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