yarp 0.6.0 → 0.8.0

data/lib/yarp/node.rb

@@ -33,7 +33,6 @@ module YARP
       visitor.visit_alias_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [new_name, old_name]
@@ -80,7 +79,6 @@ module YARP
       visitor.visit_alternation_pattern_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [left, right]
@@ -127,7 +125,6 @@ module YARP
       visitor.visit_and_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [left, right]
@@ -147,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
@@ -166,7 +209,6 @@ module YARP
       visitor.visit_arguments_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [*arguments]
@@ -209,7 +251,6 @@ module YARP
       visitor.visit_array_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [*elements]
@@ -285,7 +326,6 @@ module YARP
       visitor.visit_array_pattern_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [constant, *requireds, rest, *posts]
@@ -337,7 +377,6 @@ module YARP
       visitor.visit_assoc_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [key, value]
@@ -380,7 +419,6 @@ module YARP
       visitor.visit_assoc_splat_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [value]
@@ -415,7 +453,6 @@ module YARP
       visitor.visit_back_reference_read_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -522,7 +559,6 @@ module YARP
       visitor.visit_block_argument_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [expression]
@@ -553,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
@@ -562,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
@@ -577,10 +613,9 @@ module YARP
       visitor.visit_block_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [parameters, statements]
+      [parameters, body]
     end
 
     # def deconstruct: () -> Array[nil | Node]
@@ -588,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
@@ -626,7 +661,6 @@ module YARP
       visitor.visit_block_parameter_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -686,7 +720,6 @@ module YARP
       visitor.visit_block_parameters_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [parameters]
@@ -734,7 +767,6 @@ module YARP
       visitor.visit_break_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [arguments]
@@ -820,7 +852,6 @@ module YARP
       visitor.visit_call_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [receiver, arguments, block]
@@ -853,6 +884,16 @@ module YARP
     def closing
       closing_loc&.slice
     end
+
+    # def safe_navigation?: () -> bool
+    def safe_navigation?
+      flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
+    end
+
+    # def variable_call?: () -> bool
+    def variable_call?
+      flags.anybits?(CallNodeFlags::VARIABLE_CALL)
+    end
   end
 
   # Represents the use of the `&&=` operator on a call.
@@ -882,7 +923,6 @@ module YARP
       visitor.visit_call_operator_and_write_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [target, value]
@@ -929,7 +969,6 @@ module YARP
       visitor.visit_call_operator_or_write_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [target, value]
@@ -980,7 +1019,6 @@ module YARP
       visitor.visit_call_operator_write_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [target, value]
@@ -1027,7 +1065,6 @@ module YARP
       visitor.visit_capture_pattern_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [value, target]
@@ -1084,7 +1121,6 @@ module YARP
       visitor.visit_case_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [predicate, *conditions, consequent]
@@ -1129,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
@@ -1152,10 +1188,9 @@ module YARP
       visitor.visit_class_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [constant_path, superclass, statements]
+      [constant_path, superclass, body]
     end
 
     # def deconstruct: () -> Array[nil | Node]
@@ -1163,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
@@ -1182,34 +1217,62 @@ 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]
     def child_nodes
       [value]
@@ -1220,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
@@ -1228,43 +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]
@@ -1272,55 +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]
@@ -1328,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
@@ -1349,10 +1407,9 @@ 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]
     def child_nodes
       []
@@ -1367,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
 
@@ -1391,10 +1448,9 @@ 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]
     def child_nodes
       [value]
@@ -1419,500 +1475,23 @@ 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 :operator_loc
+    # attr_reader receiver: Node?
+    attr_reader :receiver
 
-    # attr_reader value: Node
-    attr_reader :value
+    # attr_reader parameters: Node?
+    attr_reader :parameters
 
-    # 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_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, 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 body: Node?
+    attr_reader :body
 
     # attr_reader locals: Array[Symbol]
     attr_reader :locals
@@ -1935,12 +1514,12 @@ module YARP
     # 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)
+    # 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
-      @statements = statements
+      @body = body
       @locals = locals
       @def_keyword_loc = def_keyword_loc
       @operator_loc = operator_loc
@@ -1956,10 +1535,9 @@ module YARP
       visitor.visit_def_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [receiver, parameters, statements]
+      [receiver, parameters, body]
     end
 
     # def deconstruct: () -> Array[nil | Node]
@@ -1967,7 +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, 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
@@ -2037,7 +1615,6 @@ module YARP
       visitor.visit_defined_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [value]
@@ -2094,7 +1671,6 @@ module YARP
       visitor.visit_else_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [statements]
@@ -2146,7 +1722,6 @@ module YARP
       visitor.visit_embedded_statements_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [statements]
@@ -2194,7 +1769,6 @@ module YARP
       visitor.visit_embedded_variable_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [variable]
@@ -2245,7 +1819,6 @@ module YARP
       visitor.visit_ensure_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [statements]
@@ -2285,7 +1858,6 @@ module YARP
       visitor.visit_false_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -2345,7 +1917,6 @@ module YARP
       visitor.visit_find_pattern_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [constant, left, *requireds, right]
@@ -2370,6 +1941,61 @@ module YARP
     end
   end
 
+  # Represents the use of the `..` or `...` operators to create flip flops.
+  #
+  #     baz if foo .. bar
+  #            ^^^^^^^^^^
+  class FlipFlopNode < Node
+    # attr_reader left: Node?
+    attr_reader :left
+
+    # attr_reader right: Node?
+    attr_reader :right
+
+    # attr_reader operator_loc: Location
+    attr_reader :operator_loc
+
+    # attr_reader flags: Integer
+    attr_reader :flags
+
+    # def initialize: (left: Node?, right: Node?, operator_loc: Location, flags: Integer, location: Location) -> void
+    def initialize(left, right, operator_loc, flags, location)
+      @left = left
+      @right = right
+      @operator_loc = operator_loc
+      @flags = flags
+      @location = location
+    end
+
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_flip_flop_node(self)
+    end
+
+    # def child_nodes: () -> Array[nil | Node]
+    def child_nodes
+      [left, right]
+    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)
+      { left: left, right: right, operator_loc: operator_loc, flags: flags, location: location }
+    end
+
+    # def operator: () -> String
+    def operator
+      operator_loc.slice
+    end
+
+    # def exclude_end?: () -> bool
+    def exclude_end?
+      flags.anybits?(RangeFlags::EXCLUDE_END)
+    end
+  end
+
   # Represents a floating point number literal.
   #
   #     1.0
@@ -2385,7 +2011,6 @@ module YARP
       visitor.visit_float_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -2443,7 +2068,6 @@ module YARP
       visitor.visit_for_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [index, collection, statements]
@@ -2473,139 +2097,31 @@ module YARP
     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
-  end
-
-  # Represents the use of the `&&=` operator for assignment to a global variable.
-  #
-  #     $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 end_keyword
+      end_keyword_loc.slice
+    end
+  end
 
-    # 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
+  # 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_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]
@@ -2613,51 +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]
@@ -2665,55 +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]
@@ -2721,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
 
@@ -2745,7 +2211,6 @@ module YARP
       visitor.visit_global_variable_read_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -2787,7 +2252,6 @@ module YARP
       visitor.visit_global_variable_write_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [value]
@@ -2839,7 +2303,6 @@ module YARP
       visitor.visit_hash_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [*elements]
@@ -2902,7 +2365,6 @@ module YARP
       visitor.visit_hash_pattern_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [constant, *assocs, kwrest]
@@ -2993,179 +2455,28 @@ module YARP
     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
-
-    # 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_instance_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, 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 an instance variable.
-  #
-  #     @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
+  # Represents an imaginary number literal.
+  #
+  #     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]
@@ -3173,55 +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]
@@ -3229,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
 
@@ -3253,7 +2558,6 @@ module YARP
       visitor.visit_instance_variable_read_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -3295,7 +2599,6 @@ module YARP
       visitor.visit_instance_variable_write_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [value]
@@ -3335,7 +2638,6 @@ module YARP
       visitor.visit_integer_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -3408,6 +2710,46 @@ module YARP
     def closing
       closing_loc.slice
     end
+
+    # def ignore_case?: () -> bool
+    def ignore_case?
+      flags.anybits?(RegularExpressionFlags::IGNORE_CASE)
+    end
+
+    # def multi_line?: () -> bool
+    def multi_line?
+      flags.anybits?(RegularExpressionFlags::MULTI_LINE)
+    end
+
+    # def extended?: () -> bool
+    def extended?
+      flags.anybits?(RegularExpressionFlags::EXTENDED)
+    end
+
+    # def euc_jp?: () -> bool
+    def euc_jp?
+      flags.anybits?(RegularExpressionFlags::EUC_JP)
+    end
+
+    # def ascii_8bit?: () -> bool
+    def ascii_8bit?
+      flags.anybits?(RegularExpressionFlags::ASCII_8BIT)
+    end
+
+    # def windows_31j?: () -> bool
+    def windows_31j?
+      flags.anybits?(RegularExpressionFlags::WINDOWS_31J)
+    end
+
+    # def utf_8?: () -> bool
+    def utf_8?
+      flags.anybits?(RegularExpressionFlags::UTF_8)
+    end
+
+    # def once?: () -> bool
+    def once?
+      flags.anybits?(RegularExpressionFlags::ONCE)
+    end
   end
 
   # Represents a string literal that contains interpolation.
@@ -3597,7 +2939,6 @@ module YARP
       visitor.visit_keyword_hash_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [*elements]
@@ -3640,7 +2981,6 @@ module YARP
       visitor.visit_keyword_parameter_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [value]
@@ -3684,7 +3024,6 @@ module YARP
       visitor.visit_keyword_rest_parameter_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -3723,194 +3062,26 @@ module YARP
     # 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 }
-    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.
-  #
-  #     target ||= value
-  #     ^^^^^^^^^^^^^^^^
-  class LocalVariableOperatorOrWriteNode < 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_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, constant_id: constant_id, 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 local variable using an operator that isn't `=`.
-  #
-  #     target += value
-  #     ^^^^^^^^^^^^^^^
-  class LocalVariableOperatorWriteNode < 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
-
-    # attr_reader operator_id: Symbol
-    attr_reader :operator_id
-
-    # 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
+    # attr_reader body: Node?
+    attr_reader :body
+
+    # 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]
@@ -3918,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 }
+      { locals: locals, opening_loc: opening_loc, parameters: parameters, body: body, location: location }
     end
 
-    # def name: () -> String
-    def name
-      name_loc.slice
-    end
-
-    # def operator: () -> String
-    def operator
-      operator_loc.slice
+    # def opening: () -> String
+    def opening
+      opening_loc.slice
     end
   end
 
@@ -3957,7 +3123,6 @@ module YARP
       visitor.visit_local_variable_read_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -4007,7 +3172,6 @@ module YARP
       visitor.visit_local_variable_write_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [value]
@@ -4059,7 +3223,6 @@ module YARP
       visitor.visit_match_predicate_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [value, pattern]
@@ -4106,7 +3269,6 @@ module YARP
       visitor.visit_match_required_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [value, pattern]
@@ -4139,7 +3301,6 @@ module YARP
       visitor.visit_missing_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -4168,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
@@ -4189,10 +3350,9 @@ module YARP
       visitor.visit_module_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [constant_path, statements]
+      [constant_path, body]
     end
 
     # def deconstruct: () -> Array[nil | Node]
@@ -4200,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
@@ -4249,7 +3409,6 @@ module YARP
       visitor.visit_multi_write_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [*targets, value]
@@ -4302,7 +3461,6 @@ module YARP
       visitor.visit_next_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [arguments]
@@ -4337,7 +3495,6 @@ module YARP
       visitor.visit_nil_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -4376,7 +3533,6 @@ module YARP
       visitor.visit_no_keywords_parameter_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -4416,7 +3572,6 @@ module YARP
       visitor.visit_numbered_reference_read_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -4431,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)
@@ -4463,7 +3663,6 @@ module YARP
       visitor.visit_optional_parameter_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [value]
@@ -4515,7 +3714,6 @@ module YARP
       visitor.visit_or_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [left, right]
@@ -4535,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)
@@ -4579,7 +3823,6 @@ module YARP
       visitor.visit_parameters_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [*requireds, *optionals, *posts, rest, *keywords, keyword_rest, block]
@@ -4599,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
@@ -4608,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
@@ -4627,7 +3870,7 @@ module YARP
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [statements]
+      [body]
     end
 
     # def deconstruct: () -> Array[nil | Node]
@@ -4635,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
@@ -4681,7 +3924,6 @@ module YARP
       visitor.visit_pinned_expression_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [expression]
@@ -4735,7 +3977,6 @@ module YARP
       visitor.visit_pinned_variable_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [variable]
@@ -4786,7 +4027,6 @@ module YARP
       visitor.visit_post_execution_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [statements]
@@ -4847,7 +4087,6 @@ module YARP
       visitor.visit_pre_execution_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [statements]
@@ -4897,7 +4136,6 @@ module YARP
       visitor.visit_program_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [statements]
@@ -4946,7 +4184,6 @@ module YARP
       visitor.visit_range_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [left, right]
@@ -4964,6 +4201,11 @@ module YARP
     def operator
       operator_loc.slice
     end
+
+    # def exclude_end?: () -> bool
+    def exclude_end?
+      flags.anybits?(RangeFlags::EXCLUDE_END)
+    end
   end
 
   # Represents a rational number literal.
@@ -4985,7 +4227,6 @@ module YARP
       visitor.visit_rational_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [numeric]
@@ -5015,7 +4256,6 @@ module YARP
       visitor.visit_redo_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -5065,7 +4305,6 @@ module YARP
       visitor.visit_regular_expression_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -5093,6 +4332,46 @@ module YARP
     def closing
       closing_loc.slice
     end
+
+    # def ignore_case?: () -> bool
+    def ignore_case?
+      flags.anybits?(RegularExpressionFlags::IGNORE_CASE)
+    end
+
+    # def multi_line?: () -> bool
+    def multi_line?
+      flags.anybits?(RegularExpressionFlags::MULTI_LINE)
+    end
+
+    # def extended?: () -> bool
+    def extended?
+      flags.anybits?(RegularExpressionFlags::EXTENDED)
+    end
+
+    # def euc_jp?: () -> bool
+    def euc_jp?
+      flags.anybits?(RegularExpressionFlags::EUC_JP)
+    end
+
+    # def ascii_8bit?: () -> bool
+    def ascii_8bit?
+      flags.anybits?(RegularExpressionFlags::ASCII_8BIT)
+    end
+
+    # def windows_31j?: () -> bool
+    def windows_31j?
+      flags.anybits?(RegularExpressionFlags::WINDOWS_31J)
+    end
+
+    # def utf_8?: () -> bool
+    def utf_8?
+      flags.anybits?(RegularExpressionFlags::UTF_8)
+    end
+
+    # def once?: () -> bool
+    def once?
+      flags.anybits?(RegularExpressionFlags::ONCE)
+    end
   end
 
   # Represents a destructured required parameter node.
@@ -5123,7 +4402,6 @@ module YARP
       visitor.visit_required_destructured_parameter_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [*parameters]
@@ -5168,7 +4446,6 @@ module YARP
       visitor.visit_required_parameter_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -5278,7 +4555,6 @@ module YARP
       visitor.visit_rescue_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [*exceptions, reference, statements, consequent]
@@ -5327,7 +4603,6 @@ module YARP
       visitor.visit_rest_parameter_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -5367,7 +4642,6 @@ module YARP
       visitor.visit_retry_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -5405,7 +4679,6 @@ module YARP
       visitor.visit_return_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [arguments]
@@ -5440,7 +4713,6 @@ module YARP
       visitor.visit_self_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -5472,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
@@ -5494,10 +4766,9 @@ module YARP
       visitor.visit_singleton_class_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [expression, statements]
+      [expression, body]
     end
 
     # def deconstruct: () -> Array[nil | Node]
@@ -5505,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
@@ -5539,7 +4810,6 @@ module YARP
       visitor.visit_source_encoding_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -5573,7 +4843,6 @@ module YARP
       visitor.visit_source_file_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -5603,7 +4872,6 @@ module YARP
       visitor.visit_source_line_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -5641,7 +4909,6 @@ module YARP
       visitor.visit_splat_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [expression]
@@ -5680,7 +4947,6 @@ module YARP
       visitor.visit_statements_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [*body]
@@ -5718,7 +4984,6 @@ module YARP
       visitor.visit_string_concat_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [left, right]
@@ -5771,7 +5036,6 @@ module YARP
       visitor.visit_string_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -5839,7 +5103,6 @@ module YARP
       visitor.visit_super_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [arguments, block]
@@ -5903,7 +5166,6 @@ module YARP
       visitor.visit_symbol_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -5948,7 +5210,6 @@ module YARP
       visitor.visit_true_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -5986,7 +5247,6 @@ module YARP
       visitor.visit_undef_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [*names]
@@ -6127,12 +5387,19 @@ module YARP
     def keyword
       keyword_loc.slice
     end
+
+    # def begin_modifier?: () -> bool
+    def begin_modifier?
+      flags.anybits?(LoopFlags::BEGIN_MODIFIER)
+    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
@@ -6156,7 +5423,6 @@ module YARP
       visitor.visit_when_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [*conditions, statements]
@@ -6231,6 +5497,11 @@ module YARP
     def keyword
       keyword_loc.slice
     end
+
+    # def begin_modifier?: () -> bool
+    def begin_modifier?
+      flags.anybits?(LoopFlags::BEGIN_MODIFIER)
+    end
   end
 
   # Represents an xstring literal with no interpolation.
@@ -6264,7 +5535,6 @@ module YARP
       visitor.visit_x_string_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       []
@@ -6325,7 +5595,6 @@ module YARP
       visitor.visit_yield_node(self)
     end
 
-
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
       [arguments]
@@ -6368,7 +5637,7 @@ module YARP
     BEGIN_MODIFIER = 1 << 0
   end
 
-  module RangeNodeFlags
+  module RangeFlags
     # ... operator
     EXCLUDE_END = 1 << 0
   end
@@ -6409,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
 
@@ -6466,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
 
@@ -6535,6 +5780,9 @@ module YARP
     # Visit a FindPatternNode node
     alias visit_find_pattern_node visit_child_nodes
 
+    # Visit a FlipFlopNode node
+    alias visit_flip_flop_node visit_child_nodes
+
     # Visit a FloatNode node
     alias visit_float_node visit_child_nodes
 
@@ -6550,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
 
@@ -6580,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
 
@@ -6622,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
 
@@ -6664,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
 
@@ -6805,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)
@@ -6846,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
@@ -6896,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
@@ -6925,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)
@@ -6976,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
@@ -7015,6 +6202,11 @@ module YARP
       FindPatternNode.new(constant, left, requireds, right, opening_loc, closing_loc, location)
     end
 
+    # Create a new FlipFlopNode node
+    def FlipFlopNode(left, right, operator_loc, flags, location = Location())
+      FlipFlopNode.new(left, right, operator_loc, flags, location)
+    end
+
     # Create a new FloatNode node
     def FloatNode(location = Location())
       FloatNode.new(location)
@@ -7040,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)
@@ -7090,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)
@@ -7156,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
@@ -7201,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
@@ -7230,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)
@@ -7240,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
@@ -7336,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