yarp 0.7.0 → 0.9.0

data/lib/yarp/node.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 =begin
-This file is generated by the bin/template script and should not be
+This file is generated by the templates/template.rb script and should not be
 modified manually. See templates/lib/yarp/node.rb.erb
 if you are looking to modify the template
 =end
@@ -38,6 +38,16 @@ module YARP
       [new_name, old_name]
     end
 
+    # def copy: (**params) -> AliasNode
+    def copy(**params)
+      AliasNode.new(
+        params.fetch(:new_name) { new_name },
+        params.fetch(:old_name) { old_name },
+        params.fetch(:keyword_loc) { keyword_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -84,6 +94,16 @@ module YARP
       [left, right]
     end
 
+    # def copy: (**params) -> AlternationPatternNode
+    def copy(**params)
+      AlternationPatternNode.new(
+        params.fetch(:left) { left },
+        params.fetch(:right) { right },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -130,6 +150,16 @@ module YARP
       [left, right]
     end
 
+    # def copy: (**params) -> AndNode
+    def copy(**params)
+      AndNode.new(
+        params.fetch(:left) { left },
+        params.fetch(:right) { right },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -168,6 +198,14 @@ module YARP
       [*arguments]
     end
 
+    # def copy: (**params) -> ArgumentsNode
+    def copy(**params)
+      ArgumentsNode.new(
+        params.fetch(:arguments) { arguments },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -210,6 +248,16 @@ module YARP
       [*elements]
     end
 
+    # def copy: (**params) -> ArrayNode
+    def copy(**params)
+      ArrayNode.new(
+        params.fetch(:elements) { elements },
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -285,6 +333,19 @@ module YARP
       [constant, *requireds, rest, *posts]
     end
 
+    # def copy: (**params) -> ArrayPatternNode
+    def copy(**params)
+      ArrayPatternNode.new(
+        params.fetch(:constant) { constant },
+        params.fetch(:requireds) { requireds },
+        params.fetch(:rest) { rest },
+        params.fetch(:posts) { posts },
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -336,6 +397,16 @@ module YARP
       [key, value]
     end
 
+    # def copy: (**params) -> AssocNode
+    def copy(**params)
+      AssocNode.new(
+        params.fetch(:key) { key },
+        params.fetch(:value) { value },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -378,6 +449,15 @@ module YARP
       [value]
     end
 
+    # def copy: (**params) -> AssocSplatNode
+    def copy(**params)
+      AssocSplatNode.new(
+        params.fetch(:value) { value },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -412,6 +492,13 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> BackReferenceReadNode
+    def copy(**params)
+      BackReferenceReadNode.new(
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -431,22 +518,22 @@ module YARP
     # attr_reader begin_keyword_loc: Location?
     attr_reader :begin_keyword_loc
 
-    # attr_reader statements: Node?
+    # attr_reader statements: StatementsNode?
     attr_reader :statements
 
-    # attr_reader rescue_clause: Node?
+    # attr_reader rescue_clause: RescueNode?
     attr_reader :rescue_clause
 
-    # attr_reader else_clause: Node?
+    # attr_reader else_clause: ElseNode?
     attr_reader :else_clause
 
-    # attr_reader ensure_clause: Node?
+    # attr_reader ensure_clause: EnsureNode?
     attr_reader :ensure_clause
 
     # attr_reader end_keyword_loc: Location?
     attr_reader :end_keyword_loc
 
-    # def initialize: (begin_keyword_loc: Location?, statements: Node?, rescue_clause: Node?, else_clause: Node?, ensure_clause: Node?, end_keyword_loc: Location?, location: Location) -> void
+    # def initialize: (begin_keyword_loc: Location?, statements: StatementsNode?, rescue_clause: RescueNode?, else_clause: ElseNode?, ensure_clause: EnsureNode?, end_keyword_loc: Location?, location: Location) -> void
     def initialize(begin_keyword_loc, statements, rescue_clause, else_clause, ensure_clause, end_keyword_loc, location)
       @begin_keyword_loc = begin_keyword_loc
       @statements = statements
@@ -471,6 +558,19 @@ module YARP
       [statements, rescue_clause, else_clause, ensure_clause]
     end
 
+    # def copy: (**params) -> BeginNode
+    def copy(**params)
+      BeginNode.new(
+        params.fetch(:begin_keyword_loc) { begin_keyword_loc },
+        params.fetch(:statements) { statements },
+        params.fetch(:rescue_clause) { rescue_clause },
+        params.fetch(:else_clause) { else_clause },
+        params.fetch(:ensure_clause) { ensure_clause },
+        params.fetch(:end_keyword_loc) { end_keyword_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -518,6 +618,15 @@ module YARP
       [expression]
     end
 
+    # def copy: (**params) -> BlockArgumentNode
+    def copy(**params)
+      BlockArgumentNode.new(
+        params.fetch(:expression) { expression },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -540,11 +649,11 @@ module YARP
     # attr_reader locals: Array[Symbol]
     attr_reader :locals
 
-    # attr_reader parameters: Node?
+    # attr_reader parameters: BlockParametersNode?
     attr_reader :parameters
 
-    # attr_reader statements: Node?
-    attr_reader :statements
+    # attr_reader body: Node?
+    attr_reader :body
 
     # attr_reader opening_loc: Location
     attr_reader :opening_loc
@@ -552,11 +661,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: BlockParametersNode?, body: Node?, opening_loc: Location, closing_loc: Location, location: Location) -> void
+    def initialize(locals, parameters, body, opening_loc, closing_loc, location)
       @locals = locals
       @parameters = parameters
-      @statements = statements
+      @body = body
       @opening_loc = opening_loc
       @closing_loc = closing_loc
       @location = location
@@ -569,7 +678,19 @@ module YARP
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [parameters, statements]
+      [parameters, body]
+    end
+
+    # def copy: (**params) -> BlockNode
+    def copy(**params)
+      BlockNode.new(
+        params.fetch(:locals) { locals },
+        params.fetch(:parameters) { parameters },
+        params.fetch(:body) { body },
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:location) { location },
+      )
     end
 
     # def deconstruct: () -> Array[nil | Node]
@@ -577,7 +698,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
@@ -620,6 +741,15 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> BlockParameterNode
+    def copy(**params)
+      BlockParameterNode.new(
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -648,7 +778,7 @@ module YARP
   #            ^^^^^^^^^^^^^^^^^
   #     end
   class BlockParametersNode < Node
-    # attr_reader parameters: Node?
+    # attr_reader parameters: ParametersNode?
     attr_reader :parameters
 
     # attr_reader locals: Array[Location]
@@ -660,7 +790,7 @@ module YARP
     # attr_reader closing_loc: Location?
     attr_reader :closing_loc
 
-    # def initialize: (parameters: Node?, locals: Array[Location], opening_loc: Location?, closing_loc: Location?, location: Location) -> void
+    # def initialize: (parameters: ParametersNode?, locals: Array[Location], opening_loc: Location?, closing_loc: Location?, location: Location) -> void
     def initialize(parameters, locals, opening_loc, closing_loc, location)
       @parameters = parameters
       @locals = locals
@@ -679,6 +809,17 @@ module YARP
       [parameters]
     end
 
+    # def copy: (**params) -> BlockParametersNode
+    def copy(**params)
+      BlockParametersNode.new(
+        params.fetch(:parameters) { parameters },
+        params.fetch(:locals) { locals },
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -703,13 +844,13 @@ module YARP
   #     break foo
   #     ^^^^^^^^^
   class BreakNode < Node
-    # attr_reader arguments: Node?
+    # attr_reader arguments: ArgumentsNode?
     attr_reader :arguments
 
     # attr_reader keyword_loc: Location
     attr_reader :keyword_loc
 
-    # def initialize: (arguments: Node?, keyword_loc: Location, location: Location) -> void
+    # def initialize: (arguments: ArgumentsNode?, keyword_loc: Location, location: Location) -> void
     def initialize(arguments, keyword_loc, location)
       @arguments = arguments
       @keyword_loc = keyword_loc
@@ -726,6 +867,15 @@ module YARP
       [arguments]
     end
 
+    # def copy: (**params) -> BreakNode
+    def copy(**params)
+      BreakNode.new(
+        params.fetch(:arguments) { arguments },
+        params.fetch(:keyword_loc) { keyword_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -772,13 +922,13 @@ module YARP
     # attr_reader opening_loc: Location?
     attr_reader :opening_loc
 
-    # attr_reader arguments: Node?
+    # attr_reader arguments: ArgumentsNode?
     attr_reader :arguments
 
     # attr_reader closing_loc: Location?
     attr_reader :closing_loc
 
-    # attr_reader block: Node?
+    # attr_reader block: BlockNode?
     attr_reader :block
 
     # attr_reader flags: Integer
@@ -787,7 +937,7 @@ module YARP
     # attr_reader name: String
     attr_reader :name
 
-    # def initialize: (receiver: Node?, operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: Node?, closing_loc: Location?, block: Node?, flags: Integer, name: String, location: Location) -> void
+    # def initialize: (receiver: Node?, operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: BlockNode?, flags: Integer, name: String, location: Location) -> void
     def initialize(receiver, operator_loc, message_loc, opening_loc, arguments, closing_loc, block, flags, name, location)
       @receiver = receiver
       @operator_loc = operator_loc
@@ -811,6 +961,22 @@ module YARP
       [receiver, arguments, block]
     end
 
+    # def copy: (**params) -> CallNode
+    def copy(**params)
+      CallNode.new(
+        params.fetch(:receiver) { receiver },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:message_loc) { message_loc },
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:arguments) { arguments },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:block) { block },
+        params.fetch(:flags) { flags },
+        params.fetch(:name) { name },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -855,7 +1021,7 @@ module YARP
   #     foo.bar &&= value
   #     ^^^^^^^^^^^^^^^^^
   class CallOperatorAndWriteNode < Node
-    # attr_reader target: Node
+    # attr_reader target: CallNode
     attr_reader :target
 
     # attr_reader operator_loc: Location
@@ -864,7 +1030,7 @@ module YARP
     # attr_reader value: Node
     attr_reader :value
 
-    # def initialize: (target: Node, operator_loc: Location, value: Node, location: Location) -> void
+    # def initialize: (target: CallNode, operator_loc: Location, value: Node, location: Location) -> void
     def initialize(target, operator_loc, value, location)
       @target = target
       @operator_loc = operator_loc
@@ -882,6 +1048,16 @@ module YARP
       [target, value]
     end
 
+    # def copy: (**params) -> CallOperatorAndWriteNode
+    def copy(**params)
+      CallOperatorAndWriteNode.new(
+        params.fetch(:target) { target },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -901,7 +1077,7 @@ module YARP
   #     foo.bar ||= value
   #     ^^^^^^^^^^^^^^^^^
   class CallOperatorOrWriteNode < Node
-    # attr_reader target: Node
+    # attr_reader target: CallNode
     attr_reader :target
 
     # attr_reader value: Node
@@ -910,7 +1086,7 @@ module YARP
     # attr_reader operator_loc: Location
     attr_reader :operator_loc
 
-    # def initialize: (target: Node, value: Node, operator_loc: Location, location: Location) -> void
+    # def initialize: (target: CallNode, value: Node, operator_loc: Location, location: Location) -> void
     def initialize(target, value, operator_loc, location)
       @target = target
       @value = value
@@ -928,6 +1104,16 @@ module YARP
       [target, value]
     end
 
+    # def copy: (**params) -> CallOperatorOrWriteNode
+    def copy(**params)
+      CallOperatorOrWriteNode.new(
+        params.fetch(:target) { target },
+        params.fetch(:value) { value },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -947,7 +1133,7 @@ module YARP
   #     foo.bar += baz
   #     ^^^^^^^^^^^^^^
   class CallOperatorWriteNode < Node
-    # attr_reader target: Node
+    # attr_reader target: CallNode
     attr_reader :target
 
     # attr_reader operator_loc: Location
@@ -959,7 +1145,7 @@ module YARP
     # attr_reader operator_id: Symbol
     attr_reader :operator_id
 
-    # def initialize: (target: Node, operator_loc: Location, value: Node, operator_id: Symbol, location: Location) -> void
+    # def initialize: (target: CallNode, operator_loc: Location, value: Node, operator_id: Symbol, location: Location) -> void
     def initialize(target, operator_loc, value, operator_id, location)
       @target = target
       @operator_loc = operator_loc
@@ -978,6 +1164,17 @@ module YARP
       [target, value]
     end
 
+    # def copy: (**params) -> CallOperatorWriteNode
+    def copy(**params)
+      CallOperatorWriteNode.new(
+        params.fetch(:target) { target },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:operator_id) { operator_id },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -1024,6 +1221,16 @@ module YARP
       [value, target]
     end
 
+    # def copy: (**params) -> CapturePatternNode
+    def copy(**params)
+      CapturePatternNode.new(
+        params.fetch(:value) { value },
+        params.fetch(:target) { target },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -1051,7 +1258,7 @@ module YARP
     # attr_reader conditions: Array[Node]
     attr_reader :conditions
 
-    # attr_reader consequent: Node?
+    # attr_reader consequent: ElseNode?
     attr_reader :consequent
 
     # attr_reader case_keyword_loc: Location
@@ -1060,7 +1267,7 @@ module YARP
     # attr_reader end_keyword_loc: Location
     attr_reader :end_keyword_loc
 
-    # def initialize: (predicate: Node?, conditions: Array[Node], consequent: Node?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location) -> void
+    # def initialize: (predicate: Node?, conditions: Array[Node], consequent: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location, location: Location) -> void
     def initialize(predicate, conditions, consequent, case_keyword_loc, end_keyword_loc, location)
       @predicate = predicate
       @conditions = conditions
@@ -1080,6 +1287,18 @@ module YARP
       [predicate, *conditions, consequent]
     end
 
+    # def copy: (**params) -> CaseNode
+    def copy(**params)
+      CaseNode.new(
+        params.fetch(:predicate) { predicate },
+        params.fetch(:conditions) { conditions },
+        params.fetch(:consequent) { consequent },
+        params.fetch(:case_keyword_loc) { case_keyword_loc },
+        params.fetch(:end_keyword_loc) { end_keyword_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -1119,21 +1338,25 @@ 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)
+    # attr_reader name: String
+    attr_reader :name
+
+    # def initialize: (locals: Array[Symbol], class_keyword_loc: Location, constant_path: Node, inheritance_operator_loc: Location?, superclass: Node?, body: Node?, end_keyword_loc: Location, name: String, location: Location) -> void
+    def initialize(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, 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
+      @name = name
       @location = location
     end
 
@@ -1144,7 +1367,22 @@ module YARP
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [constant_path, superclass, statements]
+      [constant_path, superclass, body]
+    end
+
+    # def copy: (**params) -> ClassNode
+    def copy(**params)
+      ClassNode.new(
+        params.fetch(:locals) { locals },
+        params.fetch(:class_keyword_loc) { class_keyword_loc },
+        params.fetch(:constant_path) { constant_path },
+        params.fetch(:inheritance_operator_loc) { inheritance_operator_loc },
+        params.fetch(:superclass) { superclass },
+        params.fetch(:body) { body },
+        params.fetch(:end_keyword_loc) { end_keyword_loc },
+        params.fetch(:name) { name },
+        params.fetch(:location) { location },
+      )
     end
 
     # def deconstruct: () -> Array[nil | Node]
@@ -1152,7 +1390,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, name: name, location: location }
     end
 
     # def class_keyword: () -> String
@@ -1175,7 +1413,7 @@ module YARP
   #
   #     @@target &&= value
   #     ^^^^^^^^^^^^^^^^
-  class ClassVariableOperatorAndWriteNode < Node
+  class ClassVariableAndWriteNode < Node
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
@@ -1195,7 +1433,7 @@ module YARP
 
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_class_variable_operator_and_write_node(self)
+      visitor.visit_class_variable_and_write_node(self)
     end
 
     # def child_nodes: () -> Array[nil | Node]
@@ -1203,6 +1441,16 @@ module YARP
       [value]
     end
 
+    # def copy: (**params) -> ClassVariableAndWriteNode
+    def copy(**params)
+      ClassVariableAndWriteNode.new(
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -1222,11 +1470,11 @@ module YARP
     end
   end
 
-  # Represents the use of the `||=` operator for assignment to a class variable.
+  # Represents assigning to a class variable using an operator that isn't `=`.
   #
-  #     @@target ||= value
-  #     ^^^^^^^^^^^^^^^^^^
-  class ClassVariableOperatorOrWriteNode < Node
+  #     @@target += value
+  #     ^^^^^^^^^^^^^^^^^
+  class ClassVariableOperatorWriteNode < Node
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
@@ -1236,17 +1484,21 @@ module YARP
     # 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: 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_class_variable_operator_or_write_node(self)
+      visitor.visit_class_variable_operator_write_node(self)
     end
 
     # def child_nodes: () -> Array[nil | Node]
@@ -1254,30 +1506,36 @@ module YARP
       [value]
     end
 
+    # def copy: (**params) -> ClassVariableOperatorWriteNode
+    def copy(**params)
+      ClassVariableOperatorWriteNode.new(
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:operator) { operator },
+        params.fetch(:location) { location },
+      )
+    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 }
+      { name_loc: name_loc, operator_loc: operator_loc, value: value, operator: operator, 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 class variable using an operator that isn't `=`.
+  # Represents the use of the `||=` operator for assignment to a class variable.
   #
-  #     @@target += value
-  #     ^^^^^^^^^^^^^^^^^
-  class ClassVariableOperatorWriteNode < Node
+  #     @@target ||= value
+  #     ^^^^^^^^^^^^^^^^^^
+  class ClassVariableOrWriteNode < Node
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
@@ -1287,21 +1545,17 @@ module YARP
     # 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)
+    # 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
-      @operator = operator
       @location = location
     end
 
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_class_variable_operator_write_node(self)
+      visitor.visit_class_variable_or_write_node(self)
     end
 
     # def child_nodes: () -> Array[nil | Node]
@@ -1309,18 +1563,33 @@ module YARP
       [value]
     end
 
+    # def copy: (**params) -> ClassVariableOrWriteNode
+    def copy(**params)
+      ClassVariableOrWriteNode.new(
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:location) { location },
+      )
+    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 }
+      { 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 referencing a class variable.
@@ -1343,6 +1612,49 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> ClassVariableReadNode
+    def copy(**params)
+      ClassVariableReadNode.new(
+        params.fetch(:location) { location },
+      )
+    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 in a context that doesn't have an explicit value.
+  #
+  #     @@foo, @@bar = baz
+  #     ^^^^^  ^^^^^
+  class ClassVariableTargetNode < Node
+    # def initialize: (location: Location) -> void
+    def initialize(location)
+      @location = location
+    end
+
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_class_variable_target_node(self)
+    end
+
+    # def child_nodes: () -> Array[nil | Node]
+    def child_nodes
+      []
+    end
+
+    # def copy: (**params) -> ClassVariableTargetNode
+    def copy(**params)
+      ClassVariableTargetNode.new(
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -1384,6 +1696,16 @@ module YARP
       [value]
     end
 
+    # def copy: (**params) -> ClassVariableWriteNode
+    def copy(**params)
+      ClassVariableWriteNode.new(
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:value) { value },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -1407,7 +1729,7 @@ module YARP
   #
   #     Target &&= value
   #     ^^^^^^^^^^^^^^^^
-  class ConstantOperatorAndWriteNode < Node
+  class ConstantAndWriteNode < Node
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
@@ -1427,7 +1749,7 @@ module YARP
 
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_constant_operator_and_write_node(self)
+      visitor.visit_constant_and_write_node(self)
     end
 
     # def child_nodes: () -> Array[nil | Node]
@@ -1435,6 +1757,16 @@ module YARP
       [value]
     end
 
+    # def copy: (**params) -> ConstantAndWriteNode
+    def copy(**params)
+      ConstantAndWriteNode.new(
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -1454,11 +1786,72 @@ module YARP
     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 copy: (**params) -> ConstantOperatorWriteNode
+    def copy(**params)
+      ConstantOperatorWriteNode.new(
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:operator) { operator },
+        params.fetch(:location) { location },
+      )
+    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 the use of the `||=` operator for assignment to a constant.
   #
   #     Target ||= value
   #     ^^^^^^^^^^^^^^^^
-  class ConstantOperatorOrWriteNode < Node
+  class ConstantOrWriteNode < Node
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
@@ -1478,7 +1871,7 @@ module YARP
 
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_constant_operator_or_write_node(self)
+      visitor.visit_constant_or_write_node(self)
     end
 
     # def child_nodes: () -> Array[nil | Node]
@@ -1486,6 +1879,16 @@ module YARP
       [value]
     end
 
+    # def copy: (**params) -> ConstantOrWriteNode
+    def copy(**params)
+      ConstantOrWriteNode.new(
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -1505,13 +1908,13 @@ module YARP
     end
   end
 
-  # Represents assigning to a constant using an operator that isn't `=`.
+  # Represents the use of the `&&=` operator for assignment to a constant path.
   #
-  #     Target += value
-  #     ^^^^^^^^^^^^^^^
-  class ConstantOperatorWriteNode < Node
-    # attr_reader name_loc: Location
-    attr_reader :name_loc
+  #     Parent::Child &&= value
+  #     ^^^^^^^^^^^^^^^^^^^^^^^
+  class ConstantPathAndWriteNode < Node
+    # attr_reader target: ConstantPathNode
+    attr_reader :target
 
     # attr_reader operator_loc: Location
     attr_reader :operator_loc
@@ -1519,26 +1922,32 @@ module YARP
     # 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: ConstantPathNode, 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_constant_operator_write_node(self)
+      visitor.visit_constant_path_and_write_node(self)
     end
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [value]
+      [target, value]
+    end
+
+    # def copy: (**params) -> ConstantPathAndWriteNode
+    def copy(**params)
+      ConstantPathAndWriteNode.new(
+        params.fetch(:target) { target },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:location) { location },
+      )
     end
 
     # def deconstruct: () -> Array[nil | Node]
@@ -1546,12 +1955,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, 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
 
@@ -1587,6 +1996,16 @@ module YARP
       [parent, child]
     end
 
+    # def copy: (**params) -> ConstantPathNode
+    def copy(**params)
+      ConstantPathNode.new(
+        params.fetch(:parent) { parent },
+        params.fetch(:child) { child },
+        params.fetch(:delimiter_loc) { delimiter_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -1601,12 +2020,12 @@ module YARP
     end
   end
 
-  # Represents the use of the `&&=` operator for assignment to a constant path.
+  # Represents assigning to a constant path using an operator that isn't `=`.
   #
-  #     Parent::Child &&= value
-  #     ^^^^^^^^^^^^^^^^^^^^^^^
-  class ConstantPathOperatorAndWriteNode < Node
-    # attr_reader target: Node
+  #     Parent::Child += value
+  #     ^^^^^^^^^^^^^^^^^^^^^^
+  class ConstantPathOperatorWriteNode < Node
+    # attr_reader target: ConstantPathNode
     attr_reader :target
 
     # attr_reader operator_loc: Location
@@ -1615,17 +2034,21 @@ module YARP
     # 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)
+    # attr_reader operator: Symbol
+    attr_reader :operator
+
+    # def initialize: (target: ConstantPathNode, 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_and_write_node(self)
+      visitor.visit_constant_path_operator_write_node(self)
     end
 
     # def child_nodes: () -> Array[nil | Node]
@@ -1633,17 +2056,23 @@ module YARP
       [target, value]
     end
 
+    # def copy: (**params) -> ConstantPathOperatorWriteNode
+    def copy(**params)
+      ConstantPathOperatorWriteNode.new(
+        params.fetch(:target) { target },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:operator) { operator },
+        params.fetch(:location) { location },
+      )
+    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
+      { target: target, operator_loc: operator_loc, value: value, operator: operator, location: location }
     end
   end
 
@@ -1651,8 +2080,8 @@ module YARP
   #
   #     Parent::Child ||= value
   #     ^^^^^^^^^^^^^^^^^^^^^^^
-  class ConstantPathOperatorOrWriteNode < Node
-    # attr_reader target: Node
+  class ConstantPathOrWriteNode < Node
+    # attr_reader target: ConstantPathNode
     attr_reader :target
 
     # attr_reader operator_loc: Location
@@ -1661,7 +2090,7 @@ module YARP
     # attr_reader value: Node
     attr_reader :value
 
-    # def initialize: (target: Node, operator_loc: Location, value: Node, location: Location) -> void
+    # def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, location: Location) -> void
     def initialize(target, operator_loc, value, location)
       @target = target
       @operator_loc = operator_loc
@@ -1671,7 +2100,7 @@ module YARP
 
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_constant_path_operator_or_write_node(self)
+      visitor.visit_constant_path_or_write_node(self)
     end
 
     # def child_nodes: () -> Array[nil | Node]
@@ -1679,6 +2108,16 @@ module YARP
       [target, value]
     end
 
+    # def copy: (**params) -> ConstantPathOrWriteNode
+    def copy(**params)
+      ConstantPathOrWriteNode.new(
+        params.fetch(:target) { target },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -1693,40 +2132,46 @@ module YARP
     end
   end
 
-  # Represents assigning to a constant path using an operator that isn't `=`.
+  # Represents writing to a constant path in a context that doesn't have an explicit value.
   #
-  #     Parent::Child += value
-  #     ^^^^^^^^^^^^^^^^^^^^^^
-  class ConstantPathOperatorWriteNode < Node
-    # attr_reader target: Node
-    attr_reader :target
-
-    # attr_reader operator_loc: Location
-    attr_reader :operator_loc
+  #     Foo::Foo, Bar::Bar = baz
+  #     ^^^^^^^^  ^^^^^^^^
+  class ConstantPathTargetNode < Node
+    # attr_reader parent: Node?
+    attr_reader :parent
 
-    # attr_reader value: Node
-    attr_reader :value
+    # attr_reader child: Node
+    attr_reader :child
 
-    # attr_reader operator: Symbol
-    attr_reader :operator
+    # attr_reader delimiter_loc: Location
+    attr_reader :delimiter_loc
 
-    # 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
+    # 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_operator_write_node(self)
+      visitor.visit_constant_path_target_node(self)
     end
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [target, value]
+      [parent, child]
+    end
+
+    # def copy: (**params) -> ConstantPathTargetNode
+    def copy(**params)
+      ConstantPathTargetNode.new(
+        params.fetch(:parent) { parent },
+        params.fetch(:child) { child },
+        params.fetch(:delimiter_loc) { delimiter_loc },
+        params.fetch(:location) { location },
+      )
     end
 
     # def deconstruct: () -> Array[nil | Node]
@@ -1734,7 +2179,12 @@ module YARP
 
     # 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 }
+      { parent: parent, child: child, delimiter_loc: delimiter_loc, location: location }
+    end
+
+    # def delimiter: () -> String
+    def delimiter
+      delimiter_loc.slice
     end
   end
 
@@ -1749,16 +2199,16 @@ module YARP
   #     ::Foo::Bar = 1
   #     ^^^^^^^^^^^^^^
   class ConstantPathWriteNode < Node
-    # attr_reader target: Node
+    # attr_reader target: ConstantPathNode
     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
 
-    # def initialize: (target: Node, operator_loc: Location?, value: Node?, location: Location) -> void
+    # def initialize: (target: ConstantPathNode, operator_loc: Location, value: Node, location: Location) -> void
     def initialize(target, operator_loc, value, location)
       @target = target
       @operator_loc = operator_loc
@@ -1776,6 +2226,16 @@ module YARP
       [target, value]
     end
 
+    # def copy: (**params) -> ConstantPathWriteNode
+    def copy(**params)
+      ConstantPathWriteNode.new(
+        params.fetch(:target) { target },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -1784,9 +2244,9 @@ module YARP
       { target: target, operator_loc: operator_loc, value: value, location: location }
     end
 
-    # def operator: () -> String?
+    # def operator: () -> String
     def operator
-      operator_loc&.slice
+      operator_loc.slice
     end
   end
 
@@ -1810,6 +2270,49 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> ConstantReadNode
+    def copy(**params)
+      ConstantReadNode.new(
+        params.fetch(:location) { location },
+      )
+    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 in a context that doesn't have an explicit value.
+  #
+  #     Foo, Bar = baz
+  #     ^^^  ^^^
+  class ConstantTargetNode < Node
+    # def initialize: (location: Location) -> void
+    def initialize(location)
+      @location = location
+    end
+
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_constant_target_node(self)
+    end
+
+    # def child_nodes: () -> Array[nil | Node]
+    def child_nodes
+      []
+    end
+
+    # def copy: (**params) -> ConstantTargetNode
+    def copy(**params)
+      ConstantTargetNode.new(
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -1827,13 +2330,13 @@ module YARP
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
-    # attr_reader value: Node?
+    # attr_reader value: Node
     attr_reader :value
 
-    # attr_reader operator_loc: 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: Location, value: Node, operator_loc: Location, location: Location) -> void
     def initialize(name_loc, value, operator_loc, location)
       @name_loc = name_loc
       @value = value
@@ -1851,6 +2354,16 @@ module YARP
       [value]
     end
 
+    # def copy: (**params) -> ConstantWriteNode
+    def copy(**params)
+      ConstantWriteNode.new(
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:value) { value },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -1864,9 +2377,9 @@ module YARP
       name_loc.slice
     end
 
-    # def operator: () -> String?
+    # def operator: () -> String
     def operator
-      operator_loc&.slice
+      operator_loc.slice
     end
   end
 
@@ -1882,11 +2395,11 @@ module YARP
     # attr_reader receiver: Node?
     attr_reader :receiver
 
-    # attr_reader parameters: Node?
+    # attr_reader parameters: ParametersNode?
     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
@@ -1909,12 +2422,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: ParametersNode?, 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
@@ -1932,7 +2445,25 @@ module YARP
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [receiver, parameters, statements]
+      [receiver, parameters, body]
+    end
+
+    # def copy: (**params) -> DefNode
+    def copy(**params)
+      DefNode.new(
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:receiver) { receiver },
+        params.fetch(:parameters) { parameters },
+        params.fetch(:body) { body },
+        params.fetch(:locals) { locals },
+        params.fetch(:def_keyword_loc) { def_keyword_loc },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:lparen_loc) { lparen_loc },
+        params.fetch(:rparen_loc) { rparen_loc },
+        params.fetch(:equal_loc) { equal_loc },
+        params.fetch(:end_keyword_loc) { end_keyword_loc },
+        params.fetch(:location) { location },
+      )
     end
 
     # def deconstruct: () -> Array[nil | Node]
@@ -1940,7 +2471,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
@@ -2015,6 +2546,17 @@ module YARP
       [value]
     end
 
+    # def copy: (**params) -> DefinedNode
+    def copy(**params)
+      DefinedNode.new(
+        params.fetch(:lparen_loc) { lparen_loc },
+        params.fetch(:value) { value },
+        params.fetch(:rparen_loc) { rparen_loc },
+        params.fetch(:keyword_loc) { keyword_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -2047,13 +2589,13 @@ module YARP
     # attr_reader else_keyword_loc: Location
     attr_reader :else_keyword_loc
 
-    # attr_reader statements: Node?
+    # attr_reader statements: StatementsNode?
     attr_reader :statements
 
     # attr_reader end_keyword_loc: Location?
     attr_reader :end_keyword_loc
 
-    # def initialize: (else_keyword_loc: Location, statements: Node?, end_keyword_loc: Location?, location: Location) -> void
+    # def initialize: (else_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location?, location: Location) -> void
     def initialize(else_keyword_loc, statements, end_keyword_loc, location)
       @else_keyword_loc = else_keyword_loc
       @statements = statements
@@ -2071,6 +2613,16 @@ module YARP
       [statements]
     end
 
+    # def copy: (**params) -> ElseNode
+    def copy(**params)
+      ElseNode.new(
+        params.fetch(:else_keyword_loc) { else_keyword_loc },
+        params.fetch(:statements) { statements },
+        params.fetch(:end_keyword_loc) { end_keyword_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -2098,13 +2650,13 @@ module YARP
     # attr_reader opening_loc: Location
     attr_reader :opening_loc
 
-    # attr_reader statements: Node?
+    # attr_reader statements: StatementsNode?
     attr_reader :statements
 
     # attr_reader closing_loc: Location
     attr_reader :closing_loc
 
-    # def initialize: (opening_loc: Location, statements: Node?, closing_loc: Location, location: Location) -> void
+    # def initialize: (opening_loc: Location, statements: StatementsNode?, closing_loc: Location, location: Location) -> void
     def initialize(opening_loc, statements, closing_loc, location)
       @opening_loc = opening_loc
       @statements = statements
@@ -2122,6 +2674,16 @@ module YARP
       [statements]
     end
 
+    # def copy: (**params) -> EmbeddedStatementsNode
+    def copy(**params)
+      EmbeddedStatementsNode.new(
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:statements) { statements },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -2169,6 +2731,15 @@ module YARP
       [variable]
     end
 
+    # def copy: (**params) -> EmbeddedVariableNode
+    def copy(**params)
+      EmbeddedVariableNode.new(
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:variable) { variable },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -2195,13 +2766,13 @@ module YARP
     # attr_reader ensure_keyword_loc: Location
     attr_reader :ensure_keyword_loc
 
-    # attr_reader statements: Node?
+    # attr_reader statements: StatementsNode?
     attr_reader :statements
 
     # attr_reader end_keyword_loc: Location
     attr_reader :end_keyword_loc
 
-    # def initialize: (ensure_keyword_loc: Location, statements: Node?, end_keyword_loc: Location, location: Location) -> void
+    # def initialize: (ensure_keyword_loc: Location, statements: StatementsNode?, end_keyword_loc: Location, location: Location) -> void
     def initialize(ensure_keyword_loc, statements, end_keyword_loc, location)
       @ensure_keyword_loc = ensure_keyword_loc
       @statements = statements
@@ -2219,6 +2790,16 @@ module YARP
       [statements]
     end
 
+    # def copy: (**params) -> EnsureNode
+    def copy(**params)
+      EnsureNode.new(
+        params.fetch(:ensure_keyword_loc) { ensure_keyword_loc },
+        params.fetch(:statements) { statements },
+        params.fetch(:end_keyword_loc) { end_keyword_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -2258,6 +2839,13 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> FalseNode
+    def copy(**params)
+      FalseNode.new(
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -2317,6 +2905,19 @@ module YARP
       [constant, left, *requireds, right]
     end
 
+    # def copy: (**params) -> FindPatternNode
+    def copy(**params)
+      FindPatternNode.new(
+        params.fetch(:constant) { constant },
+        params.fetch(:left) { left },
+        params.fetch(:requireds) { requireds },
+        params.fetch(:right) { right },
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -2372,6 +2973,17 @@ module YARP
       [left, right]
     end
 
+    # def copy: (**params) -> FlipFlopNode
+    def copy(**params)
+      FlipFlopNode.new(
+        params.fetch(:left) { left },
+        params.fetch(:right) { right },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:flags) { flags },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -2411,6 +3023,13 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> FloatNode
+    def copy(**params)
+      FloatNode.new(
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -2431,7 +3050,7 @@ module YARP
     # attr_reader collection: Node
     attr_reader :collection
 
-    # attr_reader statements: Node?
+    # attr_reader statements: StatementsNode?
     attr_reader :statements
 
     # attr_reader for_keyword_loc: Location
@@ -2446,7 +3065,7 @@ module YARP
     # attr_reader end_keyword_loc: Location
     attr_reader :end_keyword_loc
 
-    # def initialize: (index: Node, collection: Node, statements: Node?, for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: Location?, end_keyword_loc: Location, location: Location) -> void
+    # def initialize: (index: Node, collection: Node, statements: StatementsNode?, for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: Location?, end_keyword_loc: Location, location: Location) -> void
     def initialize(index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc, location)
       @index = index
       @collection = collection
@@ -2468,6 +3087,20 @@ module YARP
       [index, collection, statements]
     end
 
+    # def copy: (**params) -> ForNode
+    def copy(**params)
+      ForNode.new(
+        params.fetch(:index) { index },
+        params.fetch(:collection) { collection },
+        params.fetch(:statements) { statements },
+        params.fetch(:for_keyword_loc) { for_keyword_loc },
+        params.fetch(:in_keyword_loc) { in_keyword_loc },
+        params.fetch(:do_keyword_loc) { do_keyword_loc },
+        params.fetch(:end_keyword_loc) { end_keyword_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -2519,6 +3152,13 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> ForwardingArgumentsNode
+    def copy(**params)
+      ForwardingArgumentsNode.new(
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -2549,6 +3189,13 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> ForwardingParameterNode
+    def copy(**params)
+      ForwardingParameterNode.new(
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -2563,10 +3210,10 @@ module YARP
   #     super
   #     ^^^^^
   class ForwardingSuperNode < Node
-    # attr_reader block: Node?
+    # attr_reader block: BlockNode?
     attr_reader :block
 
-    # def initialize: (block: Node?, location: Location) -> void
+    # def initialize: (block: BlockNode?, location: Location) -> void
     def initialize(block, location)
       @block = block
       @location = location
@@ -2582,6 +3229,14 @@ module YARP
       [block]
     end
 
+    # def copy: (**params) -> ForwardingSuperNode
+    def copy(**params)
+      ForwardingSuperNode.new(
+        params.fetch(:block) { block },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -2595,7 +3250,7 @@ module YARP
   #
   #     $target &&= value
   #     ^^^^^^^^^^^^^^^^^
-  class GlobalVariableOperatorAndWriteNode < Node
+  class GlobalVariableAndWriteNode < Node
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
@@ -2615,7 +3270,7 @@ module YARP
 
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_global_variable_operator_and_write_node(self)
+      visitor.visit_global_variable_and_write_node(self)
     end
 
     # def child_nodes: () -> Array[nil | Node]
@@ -2623,6 +3278,16 @@ module YARP
       [value]
     end
 
+    # def copy: (**params) -> GlobalVariableAndWriteNode
+    def copy(**params)
+      GlobalVariableAndWriteNode.new(
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -2642,11 +3307,11 @@ module YARP
     end
   end
 
-  # Represents the use of the `||=` operator for assignment to a global variable.
+  # Represents assigning to a global variable using an operator that isn't `=`.
   #
-  #     $target ||= value
-  #     ^^^^^^^^^^^^^^^^^
-  class GlobalVariableOperatorOrWriteNode < Node
+  #     $target += value
+  #     ^^^^^^^^^^^^^^^^
+  class GlobalVariableOperatorWriteNode < Node
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
@@ -2656,17 +3321,21 @@ module YARP
     # 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: 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_global_variable_operator_or_write_node(self)
+      visitor.visit_global_variable_operator_write_node(self)
     end
 
     # def child_nodes: () -> Array[nil | Node]
@@ -2674,30 +3343,36 @@ module YARP
       [value]
     end
 
+    # def copy: (**params) -> GlobalVariableOperatorWriteNode
+    def copy(**params)
+      GlobalVariableOperatorWriteNode.new(
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:operator) { operator },
+        params.fetch(:location) { location },
+      )
+    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 }
+      { name_loc: name_loc, operator_loc: operator_loc, value: value, operator: operator, 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 global variable using an operator that isn't `=`.
+  # Represents the use of the `||=` operator for assignment to a global variable.
   #
-  #     $target += value
-  #     ^^^^^^^^^^^^^^^^
-  class GlobalVariableOperatorWriteNode < Node
+  #     $target ||= value
+  #     ^^^^^^^^^^^^^^^^^
+  class GlobalVariableOrWriteNode < Node
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
@@ -2707,21 +3382,17 @@ module YARP
     # 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)
+    # 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
-      @operator = operator
       @location = location
     end
 
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_global_variable_operator_write_node(self)
+      visitor.visit_global_variable_or_write_node(self)
     end
 
     # def child_nodes: () -> Array[nil | Node]
@@ -2729,18 +3400,33 @@ module YARP
       [value]
     end
 
+    # def copy: (**params) -> GlobalVariableOrWriteNode
+    def copy(**params)
+      GlobalVariableOrWriteNode.new(
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:location) { location },
+      )
+    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 }
+      { 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 referencing a global variable.
@@ -2763,6 +3449,49 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> GlobalVariableReadNode
+    def copy(**params)
+      GlobalVariableReadNode.new(
+        params.fetch(:location) { location },
+      )
+    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 global variable in a context that doesn't have an explicit value.
+  #
+  #     $foo, $bar = baz
+  #     ^^^^  ^^^^
+  class GlobalVariableTargetNode < Node
+    # def initialize: (location: Location) -> void
+    def initialize(location)
+      @location = location
+    end
+
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_global_variable_target_node(self)
+    end
+
+    # def child_nodes: () -> Array[nil | Node]
+    def child_nodes
+      []
+    end
+
+    # def copy: (**params) -> GlobalVariableTargetNode
+    def copy(**params)
+      GlobalVariableTargetNode.new(
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -2780,13 +3509,13 @@ module YARP
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
-    # 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
 
-    # def initialize: (name_loc: Location, operator_loc: Location?, value: Node?, location: Location) -> void
+    # 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
@@ -2804,6 +3533,16 @@ module YARP
       [value]
     end
 
+    # def copy: (**params) -> GlobalVariableWriteNode
+    def copy(**params)
+      GlobalVariableWriteNode.new(
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -2817,9 +3556,9 @@ module YARP
       name_loc.slice
     end
 
-    # def operator: () -> String?
+    # def operator: () -> String
     def operator
-      operator_loc&.slice
+      operator_loc.slice
     end
   end
 
@@ -2855,6 +3594,16 @@ module YARP
       [*elements]
     end
 
+    # def copy: (**params) -> HashNode
+    def copy(**params)
+      HashNode.new(
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:elements) { elements },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -2917,6 +3666,18 @@ module YARP
       [constant, *assocs, kwrest]
     end
 
+    # def copy: (**params) -> HashPatternNode
+    def copy(**params)
+      HashPatternNode.new(
+        params.fetch(:constant) { constant },
+        params.fetch(:assocs) { assocs },
+        params.fetch(:kwrest) { kwrest },
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -2950,7 +3711,7 @@ module YARP
     # attr_reader predicate: Node
     attr_reader :predicate
 
-    # attr_reader statements: Node?
+    # attr_reader statements: StatementsNode?
     attr_reader :statements
 
     # attr_reader consequent: Node?
@@ -2959,7 +3720,7 @@ module YARP
     # attr_reader end_keyword_loc: Location?
     attr_reader :end_keyword_loc
 
-    # def initialize: (if_keyword_loc: Location?, predicate: Node, statements: Node?, consequent: Node?, end_keyword_loc: Location?, location: Location) -> void
+    # def initialize: (if_keyword_loc: Location?, predicate: Node, statements: StatementsNode?, consequent: Node?, end_keyword_loc: Location?, location: Location) -> void
     def initialize(if_keyword_loc, predicate, statements, consequent, end_keyword_loc, location)
       @if_keyword_loc = if_keyword_loc
       @predicate = predicate
@@ -2983,6 +3744,18 @@ module YARP
       [predicate, statements, consequent]
     end
 
+    # def copy: (**params) -> IfNode
+    def copy(**params)
+      IfNode.new(
+        params.fetch(:if_keyword_loc) { if_keyword_loc },
+        params.fetch(:predicate) { predicate },
+        params.fetch(:statements) { statements },
+        params.fetch(:consequent) { consequent },
+        params.fetch(:end_keyword_loc) { end_keyword_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -3026,6 +3799,14 @@ module YARP
       [numeric]
     end
 
+    # def copy: (**params) -> ImaginaryNode
+    def copy(**params)
+      ImaginaryNode.new(
+        params.fetch(:numeric) { numeric },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -3043,7 +3824,7 @@ module YARP
     # attr_reader pattern: Node
     attr_reader :pattern
 
-    # attr_reader statements: Node?
+    # attr_reader statements: StatementsNode?
     attr_reader :statements
 
     # attr_reader in_loc: Location
@@ -3052,7 +3833,7 @@ module YARP
     # 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: Node, statements: StatementsNode?, in_loc: Location, then_loc: Location?, location: Location) -> void
     def initialize(pattern, statements, in_loc, then_loc, location)
       @pattern = pattern
       @statements = statements
@@ -3071,6 +3852,17 @@ module YARP
       [pattern, statements]
     end
 
+    # def copy: (**params) -> InNode
+    def copy(**params)
+      InNode.new(
+        params.fetch(:pattern) { pattern },
+        params.fetch(:statements) { statements },
+        params.fetch(:in_loc) { in_loc },
+        params.fetch(:then_loc) { then_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -3094,7 +3886,7 @@ module YARP
   #
   #     @target &&= value
   #     ^^^^^^^^^^^^^^^^^
-  class InstanceVariableOperatorAndWriteNode < Node
+  class InstanceVariableAndWriteNode < Node
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
@@ -3114,7 +3906,7 @@ module YARP
 
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_instance_variable_operator_and_write_node(self)
+      visitor.visit_instance_variable_and_write_node(self)
     end
 
     # def child_nodes: () -> Array[nil | Node]
@@ -3122,6 +3914,16 @@ module YARP
       [value]
     end
 
+    # def copy: (**params) -> InstanceVariableAndWriteNode
+    def copy(**params)
+      InstanceVariableAndWriteNode.new(
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -3141,11 +3943,11 @@ module YARP
     end
   end
 
-  # Represents the use of the `||=` operator for assignment to an instance variable.
+  # Represents assigning to an instance variable using an operator that isn't `=`.
   #
-  #     @target ||= value
-  #     ^^^^^^^^^^^^^^^^^
-  class InstanceVariableOperatorOrWriteNode < Node
+  #     @target += value
+  #     ^^^^^^^^^^^^^^^^
+  class InstanceVariableOperatorWriteNode < Node
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
@@ -3155,17 +3957,21 @@ module YARP
     # 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: 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_instance_variable_operator_or_write_node(self)
+      visitor.visit_instance_variable_operator_write_node(self)
     end
 
     # def child_nodes: () -> Array[nil | Node]
@@ -3173,30 +3979,36 @@ module YARP
       [value]
     end
 
+    # def copy: (**params) -> InstanceVariableOperatorWriteNode
+    def copy(**params)
+      InstanceVariableOperatorWriteNode.new(
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:operator) { operator },
+        params.fetch(:location) { location },
+      )
+    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 }
+      { name_loc: name_loc, operator_loc: operator_loc, value: value, operator: operator, 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 an instance variable using an operator that isn't `=`.
+  # Represents the use of the `||=` operator for assignment to an instance variable.
   #
-  #     @target += value
-  #     ^^^^^^^^^^^^^^^^
-  class InstanceVariableOperatorWriteNode < Node
+  #     @target ||= value
+  #     ^^^^^^^^^^^^^^^^^
+  class InstanceVariableOrWriteNode < Node
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
@@ -3206,21 +4018,17 @@ module YARP
     # 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)
+    # 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
-      @operator = operator
       @location = location
     end
 
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_instance_variable_operator_write_node(self)
+      visitor.visit_instance_variable_or_write_node(self)
     end
 
     # def child_nodes: () -> Array[nil | Node]
@@ -3228,18 +4036,33 @@ module YARP
       [value]
     end
 
+    # def copy: (**params) -> InstanceVariableOrWriteNode
+    def copy(**params)
+      InstanceVariableOrWriteNode.new(
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:location) { location },
+      )
+    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 }
+      { 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 referencing an instance variable.
@@ -3262,6 +4085,49 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> InstanceVariableReadNode
+    def copy(**params)
+      InstanceVariableReadNode.new(
+        params.fetch(:location) { location },
+      )
+    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 an instance variable in a context that doesn't have an explicit value.
+  #
+  #     @foo, @bar = baz
+  #     ^^^^  ^^^^
+  class InstanceVariableTargetNode < Node
+    # def initialize: (location: Location) -> void
+    def initialize(location)
+      @location = location
+    end
+
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_instance_variable_target_node(self)
+    end
+
+    # def child_nodes: () -> Array[nil | Node]
+    def child_nodes
+      []
+    end
+
+    # def copy: (**params) -> InstanceVariableTargetNode
+    def copy(**params)
+      InstanceVariableTargetNode.new(
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -3279,13 +4145,13 @@ module YARP
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
-    # attr_reader value: Node?
+    # attr_reader value: Node
     attr_reader :value
 
-    # attr_reader operator_loc: 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: Location, value: Node, operator_loc: Location, location: Location) -> void
     def initialize(name_loc, value, operator_loc, location)
       @name_loc = name_loc
       @value = value
@@ -3303,6 +4169,16 @@ module YARP
       [value]
     end
 
+    # def copy: (**params) -> InstanceVariableWriteNode
+    def copy(**params)
+      InstanceVariableWriteNode.new(
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:value) { value },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -3316,9 +4192,9 @@ module YARP
       name_loc.slice
     end
 
-    # def operator: () -> String?
+    # def operator: () -> String
     def operator
-      operator_loc&.slice
+      operator_loc.slice
     end
   end
 
@@ -3342,6 +4218,13 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> IntegerNode
+    def copy(**params)
+      IntegerNode.new(
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -3392,6 +4275,17 @@ module YARP
       [*parts]
     end
 
+    # def copy: (**params) -> InterpolatedRegularExpressionNode
+    def copy(**params)
+      InterpolatedRegularExpressionNode.new(
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:parts) { parts },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:flags) { flags },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -3488,6 +4382,16 @@ module YARP
       [*parts]
     end
 
+    # def copy: (**params) -> InterpolatedStringNode
+    def copy(**params)
+      InterpolatedStringNode.new(
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:parts) { parts },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -3544,6 +4448,16 @@ module YARP
       [*parts]
     end
 
+    # def copy: (**params) -> InterpolatedSymbolNode
+    def copy(**params)
+      InterpolatedSymbolNode.new(
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:parts) { parts },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -3600,6 +4514,16 @@ module YARP
       [*parts]
     end
 
+    # def copy: (**params) -> InterpolatedXStringNode
+    def copy(**params)
+      InterpolatedXStringNode.new(
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:parts) { parts },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -3643,6 +4567,14 @@ module YARP
       [*elements]
     end
 
+    # def copy: (**params) -> KeywordHashNode
+    def copy(**params)
+      KeywordHashNode.new(
+        params.fetch(:elements) { elements },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -3685,6 +4617,15 @@ module YARP
       [value]
     end
 
+    # def copy: (**params) -> KeywordParameterNode
+    def copy(**params)
+      KeywordParameterNode.new(
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:value) { value },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -3728,6 +4669,15 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> KeywordRestParameterNode
+    def copy(**params)
+      KeywordRestParameterNode.new(
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -3755,21 +4705,29 @@ module YARP
     # attr_reader locals: Array[Symbol]
     attr_reader :locals
 
+    # attr_reader operator_loc: Location
+    attr_reader :operator_loc
+
     # attr_reader opening_loc: Location
     attr_reader :opening_loc
 
-    # attr_reader parameters: Node?
+    # attr_reader closing_loc: Location
+    attr_reader :closing_loc
+
+    # attr_reader parameters: BlockParametersNode?
     attr_reader :parameters
 
-    # attr_reader statements: Node?
-    attr_reader :statements
+    # attr_reader body: Node?
+    attr_reader :body
 
-    # def initialize: (locals: Array[Symbol], opening_loc: Location, parameters: Node?, statements: Node?, location: Location) -> void
-    def initialize(locals, opening_loc, parameters, statements, location)
+    # def initialize: (locals: Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: BlockParametersNode?, body: Node?, location: Location) -> void
+    def initialize(locals, operator_loc, opening_loc, closing_loc, parameters, body, location)
       @locals = locals
+      @operator_loc = operator_loc
       @opening_loc = opening_loc
+      @closing_loc = closing_loc
       @parameters = parameters
-      @statements = statements
+      @body = body
       @location = location
     end
 
@@ -3780,7 +4738,20 @@ module YARP
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [parameters, statements]
+      [parameters, body]
+    end
+
+    # def copy: (**params) -> LambdaNode
+    def copy(**params)
+      LambdaNode.new(
+        params.fetch(:locals) { locals },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:parameters) { parameters },
+        params.fetch(:body) { body },
+        params.fetch(:location) { location },
+      )
     end
 
     # def deconstruct: () -> Array[nil | Node]
@@ -3788,20 +4759,30 @@ 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, opening_loc: opening_loc, parameters: parameters, statements: statements, location: location }
+      { locals: locals, operator_loc: operator_loc, opening_loc: opening_loc, closing_loc: closing_loc, parameters: parameters, body: body, location: location }
+    end
+
+    # def operator: () -> String
+    def operator
+      operator_loc.slice
     end
 
     # def opening: () -> String
     def opening
       opening_loc.slice
     end
+
+    # def closing: () -> String
+    def closing
+      closing_loc.slice
+    end
   end
 
   # Represents the use of the `&&=` operator for assignment to a local variable.
   #
   #     target &&= value
   #     ^^^^^^^^^^^^^^^^
-  class LocalVariableOperatorAndWriteNode < Node
+  class LocalVariableAndWriteNode < Node
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
@@ -3814,18 +4795,22 @@ module YARP
     # 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)
+    # attr_reader depth: Integer
+    attr_reader :depth
+
+    # def initialize: (name_loc: Location, operator_loc: Location, value: Node, constant_id: Symbol, depth: Integer, location: Location) -> void
+    def initialize(name_loc, operator_loc, value, constant_id, depth, location)
       @name_loc = name_loc
       @operator_loc = operator_loc
       @value = value
       @constant_id = constant_id
+      @depth = depth
       @location = location
     end
 
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_local_variable_operator_and_write_node(self)
+      visitor.visit_local_variable_and_write_node(self)
     end
 
     # def child_nodes: () -> Array[nil | Node]
@@ -3833,12 +4818,24 @@ module YARP
       [value]
     end
 
+    # def copy: (**params) -> LocalVariableAndWriteNode
+    def copy(**params)
+      LocalVariableAndWriteNode.new(
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:constant_id) { constant_id },
+        params.fetch(:depth) { depth },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, constant_id: constant_id, location: location }
+      { name_loc: name_loc, operator_loc: operator_loc, value: value, constant_id: constant_id, depth: depth, location: location }
     end
 
     # def name: () -> String
@@ -3852,11 +4849,11 @@ module YARP
     end
   end
 
-  # Represents the use of the `||=` operator for assignment to a local variable.
+  # Represents assigning to a local variable using an operator that isn't `=`.
   #
-  #     target ||= value
-  #     ^^^^^^^^^^^^^^^^
-  class LocalVariableOperatorOrWriteNode < Node
+  #     target += value
+  #     ^^^^^^^^^^^^^^^
+  class LocalVariableOperatorWriteNode < Node
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
@@ -3869,18 +4866,26 @@ module YARP
     # 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)
+    # attr_reader operator_id: Symbol
+    attr_reader :operator_id
+
+    # attr_reader depth: Integer
+    attr_reader :depth
+
+    # def initialize: (name_loc: Location, operator_loc: Location, value: Node, constant_id: Symbol, operator_id: Symbol, depth: Integer, location: Location) -> void
+    def initialize(name_loc, operator_loc, value, constant_id, operator_id, depth, location)
       @name_loc = name_loc
       @operator_loc = operator_loc
       @value = value
       @constant_id = constant_id
+      @operator_id = operator_id
+      @depth = depth
       @location = location
     end
 
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_local_variable_operator_or_write_node(self)
+      visitor.visit_local_variable_operator_write_node(self)
     end
 
     # def child_nodes: () -> Array[nil | Node]
@@ -3888,12 +4893,25 @@ module YARP
       [value]
     end
 
+    # def copy: (**params) -> LocalVariableOperatorWriteNode
+    def copy(**params)
+      LocalVariableOperatorWriteNode.new(
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:constant_id) { constant_id },
+        params.fetch(:operator_id) { operator_id },
+        params.fetch(:depth) { depth },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, constant_id: constant_id, location: location }
+      { name_loc: name_loc, operator_loc: operator_loc, value: value, constant_id: constant_id, operator_id: operator_id, depth: depth, location: location }
     end
 
     # def name: () -> String
@@ -3907,11 +4925,11 @@ module YARP
     end
   end
 
-  # Represents assigning to a local variable using an operator that isn't `=`.
+  # Represents the use of the `||=` operator for assignment to a local variable.
   #
-  #     target += value
-  #     ^^^^^^^^^^^^^^^
-  class LocalVariableOperatorWriteNode < Node
+  #     target ||= value
+  #     ^^^^^^^^^^^^^^^^
+  class LocalVariableOrWriteNode < Node
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
@@ -3924,22 +4942,22 @@ module YARP
     # attr_reader constant_id: Symbol
     attr_reader :constant_id
 
-    # attr_reader operator_id: Symbol
-    attr_reader :operator_id
+    # attr_reader depth: Integer
+    attr_reader :depth
 
-    # 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)
+    # def initialize: (name_loc: Location, operator_loc: Location, value: Node, constant_id: Symbol, depth: Integer, location: Location) -> void
+    def initialize(name_loc, operator_loc, value, constant_id, depth, location)
       @name_loc = name_loc
       @operator_loc = operator_loc
       @value = value
       @constant_id = constant_id
-      @operator_id = operator_id
+      @depth = depth
       @location = location
     end
 
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_local_variable_operator_write_node(self)
+      visitor.visit_local_variable_or_write_node(self)
     end
 
     # def child_nodes: () -> Array[nil | Node]
@@ -3947,12 +4965,24 @@ module YARP
       [value]
     end
 
+    # def copy: (**params) -> LocalVariableOrWriteNode
+    def copy(**params)
+      LocalVariableOrWriteNode.new(
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:constant_id) { constant_id },
+        params.fetch(:depth) { depth },
+        params.fetch(:location) { location },
+      )
+    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, operator_id: operator_id, location: location }
+      { name_loc: name_loc, operator_loc: operator_loc, value: value, constant_id: constant_id, depth: depth, location: location }
     end
 
     # def name: () -> String
@@ -3996,6 +5026,61 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> LocalVariableReadNode
+    def copy(**params)
+      LocalVariableReadNode.new(
+        params.fetch(:constant_id) { constant_id },
+        params.fetch(:depth) { depth },
+        params.fetch(:location) { location },
+      )
+    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)
+      { constant_id: constant_id, depth: depth, location: location }
+    end
+  end
+
+  # Represents writing to a local variable in a context that doesn't have an explicit value.
+  #
+  #     foo, bar = baz
+  #     ^^^  ^^^
+  class LocalVariableTargetNode < Node
+    # attr_reader constant_id: Symbol
+    attr_reader :constant_id
+
+    # attr_reader depth: Integer
+    attr_reader :depth
+
+    # def initialize: (constant_id: Symbol, depth: Integer, location: Location) -> void
+    def initialize(constant_id, depth, location)
+      @constant_id = constant_id
+      @depth = depth
+      @location = location
+    end
+
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_local_variable_target_node(self)
+    end
+
+    # def child_nodes: () -> Array[nil | Node]
+    def child_nodes
+      []
+    end
+
+    # def copy: (**params) -> LocalVariableTargetNode
+    def copy(**params)
+      LocalVariableTargetNode.new(
+        params.fetch(:constant_id) { constant_id },
+        params.fetch(:depth) { depth },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -4016,16 +5101,16 @@ module YARP
     # attr_reader depth: Integer
     attr_reader :depth
 
-    # attr_reader value: Node?
+    # attr_reader value: Node
     attr_reader :value
 
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
-    # attr_reader operator_loc: Location?
+    # attr_reader operator_loc: Location
     attr_reader :operator_loc
 
-    # def initialize: (constant_id: Symbol, depth: Integer, value: Node?, name_loc: Location, operator_loc: Location?, location: Location) -> void
+    # def initialize: (constant_id: Symbol, depth: Integer, value: Node, name_loc: Location, operator_loc: Location, location: Location) -> void
     def initialize(constant_id, depth, value, name_loc, operator_loc, location)
       @constant_id = constant_id
       @depth = depth
@@ -4045,6 +5130,18 @@ module YARP
       [value]
     end
 
+    # def copy: (**params) -> LocalVariableWriteNode
+    def copy(**params)
+      LocalVariableWriteNode.new(
+        params.fetch(:constant_id) { constant_id },
+        params.fetch(:depth) { depth },
+        params.fetch(:value) { value },
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -4058,9 +5155,9 @@ module YARP
       name_loc.slice
     end
 
-    # def operator: () -> String?
+    # def operator: () -> String
     def operator
-      operator_loc&.slice
+      operator_loc.slice
     end
   end
 
@@ -4096,6 +5193,16 @@ module YARP
       [value, pattern]
     end
 
+    # def copy: (**params) -> MatchPredicateNode
+    def copy(**params)
+      MatchPredicateNode.new(
+        params.fetch(:value) { value },
+        params.fetch(:pattern) { pattern },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -4142,6 +5249,16 @@ module YARP
       [value, pattern]
     end
 
+    # def copy: (**params) -> MatchRequiredNode
+    def copy(**params)
+      MatchRequiredNode.new(
+        params.fetch(:value) { value },
+        params.fetch(:pattern) { pattern },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -4174,6 +5291,13 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> MissingNode
+    def copy(**params)
+      MissingNode.new(
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -4197,19 +5321,23 @@ 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)
+    # attr_reader name: String
+    attr_reader :name
+
+    # def initialize: (locals: Array[Symbol], module_keyword_loc: Location, constant_path: Node, body: Node?, end_keyword_loc: Location, name: String, location: Location) -> void
+    def initialize(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location)
       @locals = locals
       @module_keyword_loc = module_keyword_loc
       @constant_path = constant_path
-      @statements = statements
+      @body = body
       @end_keyword_loc = end_keyword_loc
+      @name = name
       @location = location
     end
 
@@ -4220,7 +5348,20 @@ module YARP
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [constant_path, statements]
+      [constant_path, body]
+    end
+
+    # def copy: (**params) -> ModuleNode
+    def copy(**params)
+      ModuleNode.new(
+        params.fetch(:locals) { locals },
+        params.fetch(:module_keyword_loc) { module_keyword_loc },
+        params.fetch(:constant_path) { constant_path },
+        params.fetch(:body) { body },
+        params.fetch(:end_keyword_loc) { end_keyword_loc },
+        params.fetch(:name) { name },
+        params.fetch(:location) { location },
+      )
     end
 
     # def deconstruct: () -> Array[nil | Node]
@@ -4228,7 +5369,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, name: name, location: location }
     end
 
     # def module_keyword: () -> String
@@ -4282,6 +5423,18 @@ module YARP
       [*targets, value]
     end
 
+    # def copy: (**params) -> MultiWriteNode
+    def copy(**params)
+      MultiWriteNode.new(
+        params.fetch(:targets) { targets },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:lparen_loc) { lparen_loc },
+        params.fetch(:rparen_loc) { rparen_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -4311,13 +5464,13 @@ module YARP
   #     next 1
   #     ^^^^^^
   class NextNode < Node
-    # attr_reader arguments: Node?
+    # attr_reader arguments: ArgumentsNode?
     attr_reader :arguments
 
     # attr_reader keyword_loc: Location
     attr_reader :keyword_loc
 
-    # def initialize: (arguments: Node?, keyword_loc: Location, location: Location) -> void
+    # def initialize: (arguments: ArgumentsNode?, keyword_loc: Location, location: Location) -> void
     def initialize(arguments, keyword_loc, location)
       @arguments = arguments
       @keyword_loc = keyword_loc
@@ -4334,6 +5487,15 @@ module YARP
       [arguments]
     end
 
+    # def copy: (**params) -> NextNode
+    def copy(**params)
+      NextNode.new(
+        params.fetch(:arguments) { arguments },
+        params.fetch(:keyword_loc) { keyword_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -4368,6 +5530,13 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> NilNode
+    def copy(**params)
+      NilNode.new(
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -4406,6 +5575,15 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> NoKeywordsParameterNode
+    def copy(**params)
+      NoKeywordsParameterNode.new(
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:keyword_loc) { keyword_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -4445,6 +5623,13 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> NumberedReferenceReadNode
+    def copy(**params)
+      NumberedReferenceReadNode.new(
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -4491,6 +5676,17 @@ module YARP
       [value]
     end
 
+    # def copy: (**params) -> OptionalParameterNode
+    def copy(**params)
+      OptionalParameterNode.new(
+        params.fetch(:constant_id) { constant_id },
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -4542,6 +5738,16 @@ module YARP
       [left, right]
     end
 
+    # def copy: (**params) -> OrNode
+    def copy(**params)
+      OrNode.new(
+        params.fetch(:left) { left },
+        params.fetch(:right) { right },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -4571,7 +5777,7 @@ module YARP
     # attr_reader posts: Array[Node]
     attr_reader :posts
 
-    # attr_reader rest: Node?
+    # attr_reader rest: RestParameterNode?
     attr_reader :rest
 
     # attr_reader keywords: Array[Node]
@@ -4580,10 +5786,10 @@ module YARP
     # attr_reader keyword_rest: Node?
     attr_reader :keyword_rest
 
-    # attr_reader block: Node?
+    # attr_reader block: BlockParameterNode?
     attr_reader :block
 
-    # def initialize: (requireds: Array[Node], optionals: Array[Node], posts: Array[Node], rest: Node?, keywords: Array[Node], keyword_rest: Node?, block: Node?, location: Location) -> void
+    # def initialize: (requireds: Array[Node], optionals: Array[Node], posts: Array[Node], rest: RestParameterNode?, keywords: Array[Node], keyword_rest: Node?, block: BlockParameterNode?, location: Location) -> void
     def initialize(requireds, optionals, posts, rest, keywords, keyword_rest, block, location)
       @requireds = requireds
       @optionals = optionals
@@ -4605,6 +5811,20 @@ module YARP
       [*requireds, *optionals, *posts, rest, *keywords, keyword_rest, block]
     end
 
+    # def copy: (**params) -> ParametersNode
+    def copy(**params)
+      ParametersNode.new(
+        params.fetch(:requireds) { requireds },
+        params.fetch(:optionals) { optionals },
+        params.fetch(:posts) { posts },
+        params.fetch(:rest) { rest },
+        params.fetch(:keywords) { keywords },
+        params.fetch(:keyword_rest) { keyword_rest },
+        params.fetch(:block) { block },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -4619,8 +5839,8 @@ module YARP
   #     (10 + 34)
   #     ^^^^^^^^^
   class ParenthesesNode < Node
-    # attr_reader statements: Node?
-    attr_reader :statements
+    # attr_reader body: Node?
+    attr_reader :body
 
     # attr_reader opening_loc: Location
     attr_reader :opening_loc
@@ -4628,9 +5848,9 @@ module YARP
     # attr_reader closing_loc: Location
     attr_reader :closing_loc
 
-    # def initialize: (statements: Node?, opening_loc: Location, closing_loc: Location, location: Location) -> void
-    def initialize(statements, opening_loc, closing_loc, location)
-      @statements = statements
+    # def initialize: (body: Node?, opening_loc: Location, closing_loc: Location, location: Location) -> void
+    def initialize(body, opening_loc, closing_loc, location)
+      @body = body
       @opening_loc = opening_loc
       @closing_loc = closing_loc
       @location = location
@@ -4647,7 +5867,17 @@ module YARP
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [statements]
+      [body]
+    end
+
+    # def copy: (**params) -> ParenthesesNode
+    def copy(**params)
+      ParenthesesNode.new(
+        params.fetch(:body) { body },
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:location) { location },
+      )
     end
 
     # def deconstruct: () -> Array[nil | Node]
@@ -4655,7 +5885,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
@@ -4706,6 +5936,17 @@ module YARP
       [expression]
     end
 
+    # def copy: (**params) -> PinnedExpressionNode
+    def copy(**params)
+      PinnedExpressionNode.new(
+        params.fetch(:expression) { expression },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:lparen_loc) { lparen_loc },
+        params.fetch(:rparen_loc) { rparen_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -4759,6 +6000,15 @@ module YARP
       [variable]
     end
 
+    # def copy: (**params) -> PinnedVariableNode
+    def copy(**params)
+      PinnedVariableNode.new(
+        params.fetch(:variable) { variable },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -4778,7 +6028,7 @@ module YARP
   #     END { foo }
   #     ^^^^^^^^^^^
   class PostExecutionNode < Node
-    # attr_reader statements: Node?
+    # attr_reader statements: StatementsNode?
     attr_reader :statements
 
     # attr_reader keyword_loc: Location
@@ -4790,7 +6040,7 @@ module YARP
     # attr_reader closing_loc: Location
     attr_reader :closing_loc
 
-    # def initialize: (statements: Node?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location) -> void
+    # def initialize: (statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location) -> void
     def initialize(statements, keyword_loc, opening_loc, closing_loc, location)
       @statements = statements
       @keyword_loc = keyword_loc
@@ -4809,6 +6059,17 @@ module YARP
       [statements]
     end
 
+    # def copy: (**params) -> PostExecutionNode
+    def copy(**params)
+      PostExecutionNode.new(
+        params.fetch(:statements) { statements },
+        params.fetch(:keyword_loc) { keyword_loc },
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -4838,7 +6099,7 @@ module YARP
   #     BEGIN { foo }
   #     ^^^^^^^^^^^^^
   class PreExecutionNode < Node
-    # attr_reader statements: Node?
+    # attr_reader statements: StatementsNode?
     attr_reader :statements
 
     # attr_reader keyword_loc: Location
@@ -4850,7 +6111,7 @@ module YARP
     # attr_reader closing_loc: Location
     attr_reader :closing_loc
 
-    # def initialize: (statements: Node?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location) -> void
+    # def initialize: (statements: StatementsNode?, keyword_loc: Location, opening_loc: Location, closing_loc: Location, location: Location) -> void
     def initialize(statements, keyword_loc, opening_loc, closing_loc, location)
       @statements = statements
       @keyword_loc = keyword_loc
@@ -4869,6 +6130,17 @@ module YARP
       [statements]
     end
 
+    # def copy: (**params) -> PreExecutionNode
+    def copy(**params)
+      PreExecutionNode.new(
+        params.fetch(:statements) { statements },
+        params.fetch(:keyword_loc) { keyword_loc },
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -4898,10 +6170,10 @@ module YARP
     # attr_reader locals: Array[Symbol]
     attr_reader :locals
 
-    # attr_reader statements: Node
+    # attr_reader statements: StatementsNode
     attr_reader :statements
 
-    # def initialize: (locals: Array[Symbol], statements: Node, location: Location) -> void
+    # def initialize: (locals: Array[Symbol], statements: StatementsNode, location: Location) -> void
     def initialize(locals, statements, location)
       @locals = locals
       @statements = statements
@@ -4918,6 +6190,15 @@ module YARP
       [statements]
     end
 
+    # def copy: (**params) -> ProgramNode
+    def copy(**params)
+      ProgramNode.new(
+        params.fetch(:locals) { locals },
+        params.fetch(:statements) { statements },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -4966,6 +6247,17 @@ module YARP
       [left, right]
     end
 
+    # def copy: (**params) -> RangeNode
+    def copy(**params)
+      RangeNode.new(
+        params.fetch(:left) { left },
+        params.fetch(:right) { right },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:flags) { flags },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -5009,6 +6301,14 @@ module YARP
       [numeric]
     end
 
+    # def copy: (**params) -> RationalNode
+    def copy(**params)
+      RationalNode.new(
+        params.fetch(:numeric) { numeric },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -5038,6 +6338,13 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> RedoNode
+    def copy(**params)
+      RedoNode.new(
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -5087,6 +6394,18 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> RegularExpressionNode
+    def copy(**params)
+      RegularExpressionNode.new(
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:content_loc) { content_loc },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:unescaped) { unescaped },
+        params.fetch(:flags) { flags },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -5184,6 +6503,16 @@ module YARP
       [*parameters]
     end
 
+    # def copy: (**params) -> RequiredDestructuredParameterNode
+    def copy(**params)
+      RequiredDestructuredParameterNode.new(
+        params.fetch(:parameters) { parameters },
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -5228,6 +6557,14 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> RequiredParameterNode
+    def copy(**params)
+      RequiredParameterNode.new(
+        params.fetch(:constant_id) { constant_id },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -5273,6 +6610,16 @@ module YARP
       [expression, rescue_expression]
     end
 
+    # def copy: (**params) -> RescueModifierNode
+    def copy(**params)
+      RescueModifierNode.new(
+        params.fetch(:expression) { expression },
+        params.fetch(:keyword_loc) { keyword_loc },
+        params.fetch(:rescue_expression) { rescue_expression },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -5310,13 +6657,13 @@ module YARP
     # attr_reader reference: Node?
     attr_reader :reference
 
-    # attr_reader statements: Node?
+    # attr_reader statements: StatementsNode?
     attr_reader :statements
 
-    # attr_reader consequent: Node?
+    # attr_reader consequent: RescueNode?
     attr_reader :consequent
 
-    # def initialize: (keyword_loc: Location, exceptions: Array[Node], operator_loc: Location?, reference: Node?, statements: Node?, consequent: Node?, location: Location) -> void
+    # def initialize: (keyword_loc: Location, exceptions: Array[Node], operator_loc: Location?, reference: Node?, statements: StatementsNode?, consequent: RescueNode?, location: Location) -> void
     def initialize(keyword_loc, exceptions, operator_loc, reference, statements, consequent, location)
       @keyword_loc = keyword_loc
       @exceptions = exceptions
@@ -5337,6 +6684,19 @@ module YARP
       [*exceptions, reference, statements, consequent]
     end
 
+    # def copy: (**params) -> RescueNode
+    def copy(**params)
+      RescueNode.new(
+        params.fetch(:keyword_loc) { keyword_loc },
+        params.fetch(:exceptions) { exceptions },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:reference) { reference },
+        params.fetch(:statements) { statements },
+        params.fetch(:consequent) { consequent },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -5385,6 +6745,15 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> RestParameterNode
+    def copy(**params)
+      RestParameterNode.new(
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:name_loc) { name_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -5424,6 +6793,13 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> RetryNode
+    def copy(**params)
+      RetryNode.new(
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -5441,10 +6817,10 @@ module YARP
     # attr_reader keyword_loc: Location
     attr_reader :keyword_loc
 
-    # attr_reader arguments: Node?
+    # attr_reader arguments: ArgumentsNode?
     attr_reader :arguments
 
-    # def initialize: (keyword_loc: Location, arguments: Node?, location: Location) -> void
+    # def initialize: (keyword_loc: Location, arguments: ArgumentsNode?, location: Location) -> void
     def initialize(keyword_loc, arguments, location)
       @keyword_loc = keyword_loc
       @arguments = arguments
@@ -5461,6 +6837,15 @@ module YARP
       [arguments]
     end
 
+    # def copy: (**params) -> ReturnNode
+    def copy(**params)
+      ReturnNode.new(
+        params.fetch(:keyword_loc) { keyword_loc },
+        params.fetch(:arguments) { arguments },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -5495,6 +6880,13 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> SelfNode
+    def copy(**params)
+      SelfNode.new(
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -5521,19 +6913,19 @@ module YARP
     # attr_reader expression: Node
     attr_reader :expression
 
-    # attr_reader statements: Node?
-    attr_reader :statements
+    # attr_reader body: Node?
+    attr_reader :body
 
     # attr_reader end_keyword_loc: Location
     attr_reader :end_keyword_loc
 
-    # def initialize: (locals: Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Node, statements: Node?, end_keyword_loc: Location, location: Location) -> void
-    def initialize(locals, class_keyword_loc, operator_loc, expression, statements, end_keyword_loc, location)
+    # def initialize: (locals: Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Node, body: Node?, end_keyword_loc: Location, location: Location) -> void
+    def initialize(locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc, location)
       @locals = locals
       @class_keyword_loc = class_keyword_loc
       @operator_loc = operator_loc
       @expression = expression
-      @statements = statements
+      @body = body
       @end_keyword_loc = end_keyword_loc
       @location = location
     end
@@ -5545,7 +6937,20 @@ module YARP
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [expression, statements]
+      [expression, body]
+    end
+
+    # def copy: (**params) -> SingletonClassNode
+    def copy(**params)
+      SingletonClassNode.new(
+        params.fetch(:locals) { locals },
+        params.fetch(:class_keyword_loc) { class_keyword_loc },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:expression) { expression },
+        params.fetch(:body) { body },
+        params.fetch(:end_keyword_loc) { end_keyword_loc },
+        params.fetch(:location) { location },
+      )
     end
 
     # def deconstruct: () -> Array[nil | Node]
@@ -5553,7 +6958,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
@@ -5592,6 +6997,13 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> SourceEncodingNode
+    def copy(**params)
+      SourceEncodingNode.new(
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -5625,6 +7037,14 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> SourceFileNode
+    def copy(**params)
+      SourceFileNode.new(
+        params.fetch(:filepath) { filepath },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -5654,6 +7074,13 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> SourceLineNode
+    def copy(**params)
+      SourceLineNode.new(
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -5691,6 +7118,15 @@ module YARP
       [expression]
     end
 
+    # def copy: (**params) -> SplatNode
+    def copy(**params)
+      SplatNode.new(
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:expression) { expression },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -5729,6 +7165,14 @@ module YARP
       [*body]
     end
 
+    # def copy: (**params) -> StatementsNode
+    def copy(**params)
+      StatementsNode.new(
+        params.fetch(:body) { body },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -5766,6 +7210,15 @@ module YARP
       [left, right]
     end
 
+    # def copy: (**params) -> StringConcatNode
+    def copy(**params)
+      StringConcatNode.new(
+        params.fetch(:left) { left },
+        params.fetch(:right) { right },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -5818,6 +7271,17 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> StringNode
+    def copy(**params)
+      StringNode.new(
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:content_loc) { content_loc },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:unescaped) { unescaped },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -5856,16 +7320,16 @@ module YARP
     # attr_reader lparen_loc: Location?
     attr_reader :lparen_loc
 
-    # attr_reader arguments: Node?
+    # attr_reader arguments: ArgumentsNode?
     attr_reader :arguments
 
     # attr_reader rparen_loc: Location?
     attr_reader :rparen_loc
 
-    # attr_reader block: Node?
+    # attr_reader block: BlockNode?
     attr_reader :block
 
-    # def initialize: (keyword_loc: Location, lparen_loc: Location?, arguments: Node?, rparen_loc: Location?, block: Node?, location: Location) -> void
+    # def initialize: (keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, block: BlockNode?, location: Location) -> void
     def initialize(keyword_loc, lparen_loc, arguments, rparen_loc, block, location)
       @keyword_loc = keyword_loc
       @lparen_loc = lparen_loc
@@ -5885,6 +7349,18 @@ module YARP
       [arguments, block]
     end
 
+    # def copy: (**params) -> SuperNode
+    def copy(**params)
+      SuperNode.new(
+        params.fetch(:keyword_loc) { keyword_loc },
+        params.fetch(:lparen_loc) { lparen_loc },
+        params.fetch(:arguments) { arguments },
+        params.fetch(:rparen_loc) { rparen_loc },
+        params.fetch(:block) { block },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -5920,7 +7396,7 @@ module YARP
     # attr_reader opening_loc: Location?
     attr_reader :opening_loc
 
-    # attr_reader value_loc: Location
+    # attr_reader value_loc: Location?
     attr_reader :value_loc
 
     # attr_reader closing_loc: Location?
@@ -5929,7 +7405,7 @@ module YARP
     # attr_reader unescaped: String
     attr_reader :unescaped
 
-    # def initialize: (opening_loc: Location?, value_loc: Location, closing_loc: Location?, unescaped: String, location: Location) -> void
+    # def initialize: (opening_loc: Location?, value_loc: Location?, closing_loc: Location?, unescaped: String, location: Location) -> void
     def initialize(opening_loc, value_loc, closing_loc, unescaped, location)
       @opening_loc = opening_loc
       @value_loc = value_loc
@@ -5948,6 +7424,17 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> SymbolNode
+    def copy(**params)
+      SymbolNode.new(
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:value_loc) { value_loc },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:unescaped) { unescaped },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -5961,9 +7448,9 @@ module YARP
       opening_loc&.slice
     end
 
-    # def value: () -> String
+    # def value: () -> String?
     def value
-      value_loc.slice
+      value_loc&.slice
     end
 
     # def closing: () -> String?
@@ -5992,6 +7479,13 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> TrueNode
+    def copy(**params)
+      TrueNode.new(
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -6029,6 +7523,15 @@ module YARP
       [*names]
     end
 
+    # def copy: (**params) -> UndefNode
+    def copy(**params)
+      UndefNode.new(
+        params.fetch(:names) { names },
+        params.fetch(:keyword_loc) { keyword_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -6057,16 +7560,16 @@ module YARP
     # attr_reader predicate: Node
     attr_reader :predicate
 
-    # attr_reader statements: Node?
+    # attr_reader statements: StatementsNode?
     attr_reader :statements
 
-    # attr_reader consequent: Node?
+    # attr_reader consequent: ElseNode?
     attr_reader :consequent
 
     # attr_reader end_keyword_loc: Location?
     attr_reader :end_keyword_loc
 
-    # def initialize: (keyword_loc: Location, predicate: Node, statements: Node?, consequent: Node?, end_keyword_loc: Location?, location: Location) -> void
+    # def initialize: (keyword_loc: Location, predicate: Node, statements: StatementsNode?, consequent: ElseNode?, end_keyword_loc: Location?, location: Location) -> void
     def initialize(keyword_loc, predicate, statements, consequent, end_keyword_loc, location)
       @keyword_loc = keyword_loc
       @predicate = predicate
@@ -6090,6 +7593,18 @@ module YARP
       [predicate, statements, consequent]
     end
 
+    # def copy: (**params) -> UnlessNode
+    def copy(**params)
+      UnlessNode.new(
+        params.fetch(:keyword_loc) { keyword_loc },
+        params.fetch(:predicate) { predicate },
+        params.fetch(:statements) { statements },
+        params.fetch(:consequent) { consequent },
+        params.fetch(:end_keyword_loc) { end_keyword_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -6120,18 +7635,22 @@ module YARP
     # attr_reader keyword_loc: Location
     attr_reader :keyword_loc
 
+    # attr_reader closing_loc: Location?
+    attr_reader :closing_loc
+
     # attr_reader predicate: Node
     attr_reader :predicate
 
-    # attr_reader statements: Node?
+    # attr_reader statements: StatementsNode?
     attr_reader :statements
 
     # attr_reader flags: Integer
     attr_reader :flags
 
-    # def initialize: (keyword_loc: Location, predicate: Node, statements: Node?, flags: Integer, location: Location) -> void
-    def initialize(keyword_loc, predicate, statements, flags, location)
+    # def initialize: (keyword_loc: Location, closing_loc: Location?, predicate: Node, statements: StatementsNode?, flags: Integer, location: Location) -> void
+    def initialize(keyword_loc, closing_loc, predicate, statements, flags, location)
       @keyword_loc = keyword_loc
+      @closing_loc = closing_loc
       @predicate = predicate
       @statements = statements
       @flags = flags
@@ -6152,12 +7671,24 @@ module YARP
       [predicate, statements]
     end
 
+    # def copy: (**params) -> UntilNode
+    def copy(**params)
+      UntilNode.new(
+        params.fetch(:keyword_loc) { keyword_loc },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:predicate) { predicate },
+        params.fetch(:statements) { statements },
+        params.fetch(:flags) { flags },
+        params.fetch(:location) { location },
+      )
+    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)
-      { keyword_loc: keyword_loc, predicate: predicate, statements: statements, flags: flags, location: location }
+      { keyword_loc: keyword_loc, closing_loc: closing_loc, predicate: predicate, statements: statements, flags: flags, location: location }
     end
 
     # def keyword: () -> String
@@ -6165,16 +7696,23 @@ module YARP
       keyword_loc.slice
     end
 
+    # def closing: () -> String?
+    def closing
+      closing_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
@@ -6182,10 +7720,10 @@ module YARP
     # attr_reader conditions: Array[Node]
     attr_reader :conditions
 
-    # attr_reader statements: Node?
+    # attr_reader statements: StatementsNode?
     attr_reader :statements
 
-    # def initialize: (keyword_loc: Location, conditions: Array[Node], statements: Node?, location: Location) -> void
+    # def initialize: (keyword_loc: Location, conditions: Array[Node], statements: StatementsNode?, location: Location) -> void
     def initialize(keyword_loc, conditions, statements, location)
       @keyword_loc = keyword_loc
       @conditions = conditions
@@ -6203,6 +7741,16 @@ module YARP
       [*conditions, statements]
     end
 
+    # def copy: (**params) -> WhenNode
+    def copy(**params)
+      WhenNode.new(
+        params.fetch(:keyword_loc) { keyword_loc },
+        params.fetch(:conditions) { conditions },
+        params.fetch(:statements) { statements },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -6228,18 +7776,22 @@ module YARP
     # attr_reader keyword_loc: Location
     attr_reader :keyword_loc
 
+    # attr_reader closing_loc: Location?
+    attr_reader :closing_loc
+
     # attr_reader predicate: Node
     attr_reader :predicate
 
-    # attr_reader statements: Node?
+    # attr_reader statements: StatementsNode?
     attr_reader :statements
 
     # attr_reader flags: Integer
     attr_reader :flags
 
-    # def initialize: (keyword_loc: Location, predicate: Node, statements: Node?, flags: Integer, location: Location) -> void
-    def initialize(keyword_loc, predicate, statements, flags, location)
+    # def initialize: (keyword_loc: Location, closing_loc: Location?, predicate: Node, statements: StatementsNode?, flags: Integer, location: Location) -> void
+    def initialize(keyword_loc, closing_loc, predicate, statements, flags, location)
       @keyword_loc = keyword_loc
+      @closing_loc = closing_loc
       @predicate = predicate
       @statements = statements
       @flags = flags
@@ -6260,12 +7812,24 @@ module YARP
       [predicate, statements]
     end
 
+    # def copy: (**params) -> WhileNode
+    def copy(**params)
+      WhileNode.new(
+        params.fetch(:keyword_loc) { keyword_loc },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:predicate) { predicate },
+        params.fetch(:statements) { statements },
+        params.fetch(:flags) { flags },
+        params.fetch(:location) { location },
+      )
+    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)
-      { keyword_loc: keyword_loc, predicate: predicate, statements: statements, flags: flags, location: location }
+      { keyword_loc: keyword_loc, closing_loc: closing_loc, predicate: predicate, statements: statements, flags: flags, location: location }
     end
 
     # def keyword: () -> String
@@ -6273,6 +7837,11 @@ module YARP
       keyword_loc.slice
     end
 
+    # def closing: () -> String?
+    def closing
+      closing_loc&.slice
+    end
+
     # def begin_modifier?: () -> bool
     def begin_modifier?
       flags.anybits?(LoopFlags::BEGIN_MODIFIER)
@@ -6315,6 +7884,17 @@ module YARP
       []
     end
 
+    # def copy: (**params) -> XStringNode
+    def copy(**params)
+      XStringNode.new(
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:content_loc) { content_loc },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:unescaped) { unescaped },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -6350,13 +7930,13 @@ module YARP
     # attr_reader lparen_loc: Location?
     attr_reader :lparen_loc
 
-    # attr_reader arguments: Node?
+    # attr_reader arguments: ArgumentsNode?
     attr_reader :arguments
 
     # attr_reader rparen_loc: Location?
     attr_reader :rparen_loc
 
-    # def initialize: (keyword_loc: Location, lparen_loc: Location?, arguments: Node?, rparen_loc: Location?, location: Location) -> void
+    # def initialize: (keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, location: Location) -> void
     def initialize(keyword_loc, lparen_loc, arguments, rparen_loc, location)
       @keyword_loc = keyword_loc
       @lparen_loc = lparen_loc
@@ -6375,6 +7955,17 @@ module YARP
       [arguments]
     end
 
+    # def copy: (**params) -> YieldNode
+    def copy(**params)
+      YieldNode.new(
+        params.fetch(:keyword_loc) { keyword_loc },
+        params.fetch(:lparen_loc) { lparen_loc },
+        params.fetch(:arguments) { arguments },
+        params.fetch(:rparen_loc) { rparen_loc },
+        params.fetch(:location) { location },
+      )
+    end
+
     # def deconstruct: () -> Array[nil | Node]
     alias deconstruct child_nodes
 
@@ -6510,48 +8101,57 @@ 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 ClassVariableAndWriteNode node
+    alias visit_class_variable_and_write_node visit_child_nodes
 
     # Visit a ClassVariableOperatorWriteNode node
     alias visit_class_variable_operator_write_node visit_child_nodes
 
+    # Visit a ClassVariableOrWriteNode node
+    alias visit_class_variable_or_write_node visit_child_nodes
+
     # Visit a ClassVariableReadNode node
     alias visit_class_variable_read_node visit_child_nodes
 
+    # Visit a ClassVariableTargetNode node
+    alias visit_class_variable_target_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 ConstantAndWriteNode node
+    alias visit_constant_and_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 ConstantOrWriteNode node
+    alias visit_constant_or_write_node visit_child_nodes
 
-    # Visit a ConstantPathOperatorAndWriteNode node
-    alias visit_constant_path_operator_and_write_node visit_child_nodes
+    # Visit a ConstantPathAndWriteNode node
+    alias visit_constant_path_and_write_node visit_child_nodes
 
-    # Visit a ConstantPathOperatorOrWriteNode node
-    alias visit_constant_path_operator_or_write_node visit_child_nodes
+    # Visit a ConstantPathNode node
+    alias visit_constant_path_node visit_child_nodes
 
     # Visit a ConstantPathOperatorWriteNode node
     alias visit_constant_path_operator_write_node visit_child_nodes
 
+    # Visit a ConstantPathOrWriteNode node
+    alias visit_constant_path_or_write_node visit_child_nodes
+
+    # Visit a ConstantPathTargetNode node
+    alias visit_constant_path_target_node visit_child_nodes
+
     # Visit a ConstantPathWriteNode node
     alias visit_constant_path_write_node visit_child_nodes
 
     # Visit a ConstantReadNode node
     alias visit_constant_read_node visit_child_nodes
 
+    # Visit a ConstantTargetNode node
+    alias visit_constant_target_node visit_child_nodes
+
     # Visit a ConstantWriteNode node
     alias visit_constant_write_node visit_child_nodes
 
@@ -6597,18 +8197,21 @@ 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 GlobalVariableAndWriteNode node
+    alias visit_global_variable_and_write_node visit_child_nodes
 
     # Visit a GlobalVariableOperatorWriteNode node
     alias visit_global_variable_operator_write_node visit_child_nodes
 
+    # Visit a GlobalVariableOrWriteNode node
+    alias visit_global_variable_or_write_node visit_child_nodes
+
     # Visit a GlobalVariableReadNode node
     alias visit_global_variable_read_node visit_child_nodes
 
+    # Visit a GlobalVariableTargetNode node
+    alias visit_global_variable_target_node visit_child_nodes
+
     # Visit a GlobalVariableWriteNode node
     alias visit_global_variable_write_node visit_child_nodes
 
@@ -6627,18 +8230,21 @@ 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 InstanceVariableAndWriteNode node
+    alias visit_instance_variable_and_write_node visit_child_nodes
 
     # Visit a InstanceVariableOperatorWriteNode node
     alias visit_instance_variable_operator_write_node visit_child_nodes
 
+    # Visit a InstanceVariableOrWriteNode node
+    alias visit_instance_variable_or_write_node visit_child_nodes
+
     # Visit a InstanceVariableReadNode node
     alias visit_instance_variable_read_node visit_child_nodes
 
+    # Visit a InstanceVariableTargetNode node
+    alias visit_instance_variable_target_node visit_child_nodes
+
     # Visit a InstanceVariableWriteNode node
     alias visit_instance_variable_write_node visit_child_nodes
 
@@ -6669,18 +8275,21 @@ 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 LocalVariableAndWriteNode node
+    alias visit_local_variable_and_write_node visit_child_nodes
 
     # Visit a LocalVariableOperatorWriteNode node
     alias visit_local_variable_operator_write_node visit_child_nodes
 
+    # Visit a LocalVariableOrWriteNode node
+    alias visit_local_variable_or_write_node visit_child_nodes
+
     # Visit a LocalVariableReadNode node
     alias visit_local_variable_read_node visit_child_nodes
 
+    # Visit a LocalVariableTargetNode node
+    alias visit_local_variable_target_node visit_child_nodes
+
     # Visit a LocalVariableWriteNode node
     alias visit_local_variable_write_node visit_child_nodes
 
@@ -6893,8 +8502,8 @@ module YARP
     end
 
     # Create a new BlockNode node
-    def BlockNode(locals, parameters, statements, opening_loc, closing_loc, location = Location())
-      BlockNode.new(locals, parameters, statements, opening_loc, closing_loc, location)
+    def BlockNode(locals, parameters, body, opening_loc, closing_loc, location = Location())
+      BlockNode.new(locals, parameters, body, opening_loc, closing_loc, location)
     end
 
     # Create a new BlockParameterNode node
@@ -6943,18 +8552,13 @@ 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)
+    def ClassNode(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, location = Location())
+      ClassNode.new(locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name, 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)
+    # Create a new ClassVariableAndWriteNode node
+    def ClassVariableAndWriteNode(name_loc, operator_loc, value, location = Location())
+      ClassVariableAndWriteNode.new(name_loc, operator_loc, value, location)
     end
 
     # Create a new ClassVariableOperatorWriteNode node
@@ -6962,24 +8566,29 @@ module YARP
       ClassVariableOperatorWriteNode.new(name_loc, operator_loc, value, operator, location)
     end
 
+    # Create a new ClassVariableOrWriteNode node
+    def ClassVariableOrWriteNode(name_loc, operator_loc, value, location = Location())
+      ClassVariableOrWriteNode.new(name_loc, operator_loc, value, location)
+    end
+
     # Create a new ClassVariableReadNode node
     def ClassVariableReadNode(location = Location())
       ClassVariableReadNode.new(location)
     end
 
+    # Create a new ClassVariableTargetNode node
+    def ClassVariableTargetNode(location = Location())
+      ClassVariableTargetNode.new(location)
+    end
+
     # Create a new ClassVariableWriteNode node
     def ClassVariableWriteNode(name_loc, value, operator_loc, location = Location())
       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)
+    # Create a new ConstantAndWriteNode node
+    def ConstantAndWriteNode(name_loc, operator_loc, value, location = Location())
+      ConstantAndWriteNode.new(name_loc, operator_loc, value, location)
     end
 
     # Create a new ConstantOperatorWriteNode node
@@ -6987,19 +8596,19 @@ module YARP
       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)
+    # Create a new ConstantOrWriteNode node
+    def ConstantOrWriteNode(name_loc, operator_loc, value, location = Location())
+      ConstantOrWriteNode.new(name_loc, operator_loc, value, location)
     end
 
-    # Create a new ConstantPathOperatorAndWriteNode node
-    def ConstantPathOperatorAndWriteNode(target, operator_loc, value, location = Location())
-      ConstantPathOperatorAndWriteNode.new(target, operator_loc, value, location)
+    # Create a new ConstantPathAndWriteNode node
+    def ConstantPathAndWriteNode(target, operator_loc, value, location = Location())
+      ConstantPathAndWriteNode.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)
+    # Create a new ConstantPathNode node
+    def ConstantPathNode(parent, child, delimiter_loc, location = Location())
+      ConstantPathNode.new(parent, child, delimiter_loc, location)
     end
 
     # Create a new ConstantPathOperatorWriteNode node
@@ -7007,6 +8616,16 @@ module YARP
       ConstantPathOperatorWriteNode.new(target, operator_loc, value, operator, location)
     end
 
+    # Create a new ConstantPathOrWriteNode node
+    def ConstantPathOrWriteNode(target, operator_loc, value, location = Location())
+      ConstantPathOrWriteNode.new(target, operator_loc, value, location)
+    end
+
+    # Create a new ConstantPathTargetNode node
+    def ConstantPathTargetNode(parent, child, delimiter_loc, location = Location())
+      ConstantPathTargetNode.new(parent, child, delimiter_loc, location)
+    end
+
     # Create a new ConstantPathWriteNode node
     def ConstantPathWriteNode(target, operator_loc, value, location = Location())
       ConstantPathWriteNode.new(target, operator_loc, value, location)
@@ -7017,14 +8636,19 @@ module YARP
       ConstantReadNode.new(location)
     end
 
+    # Create a new ConstantTargetNode node
+    def ConstantTargetNode(location = Location())
+      ConstantTargetNode.new(location)
+    end
+
     # Create a new ConstantWriteNode node
     def ConstantWriteNode(name_loc, value, operator_loc, location = Location())
       ConstantWriteNode.new(name_loc, value, operator_loc, location)
     end
 
     # Create a new DefNode node
-    def DefNode(name_loc, receiver, parameters, statements, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location = Location())
-      DefNode.new(name_loc, receiver, parameters, statements, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location)
+    def DefNode(name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location = Location())
+      DefNode.new(name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc, location)
     end
 
     # Create a new DefinedNode node
@@ -7092,14 +8716,9 @@ 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)
+    # Create a new GlobalVariableAndWriteNode node
+    def GlobalVariableAndWriteNode(name_loc, operator_loc, value, location = Location())
+      GlobalVariableAndWriteNode.new(name_loc, operator_loc, value, location)
     end
 
     # Create a new GlobalVariableOperatorWriteNode node
@@ -7107,11 +8726,21 @@ module YARP
       GlobalVariableOperatorWriteNode.new(name_loc, operator_loc, value, operator, location)
     end
 
+    # Create a new GlobalVariableOrWriteNode node
+    def GlobalVariableOrWriteNode(name_loc, operator_loc, value, location = Location())
+      GlobalVariableOrWriteNode.new(name_loc, operator_loc, value, location)
+    end
+
     # Create a new GlobalVariableReadNode node
     def GlobalVariableReadNode(location = Location())
       GlobalVariableReadNode.new(location)
     end
 
+    # Create a new GlobalVariableTargetNode node
+    def GlobalVariableTargetNode(location = Location())
+      GlobalVariableTargetNode.new(location)
+    end
+
     # Create a new GlobalVariableWriteNode node
     def GlobalVariableWriteNode(name_loc, operator_loc, value, location = Location())
       GlobalVariableWriteNode.new(name_loc, operator_loc, value, location)
@@ -7142,14 +8771,9 @@ 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)
+    # Create a new InstanceVariableAndWriteNode node
+    def InstanceVariableAndWriteNode(name_loc, operator_loc, value, location = Location())
+      InstanceVariableAndWriteNode.new(name_loc, operator_loc, value, location)
     end
 
     # Create a new InstanceVariableOperatorWriteNode node
@@ -7157,11 +8781,21 @@ module YARP
       InstanceVariableOperatorWriteNode.new(name_loc, operator_loc, value, operator, location)
     end
 
+    # Create a new InstanceVariableOrWriteNode node
+    def InstanceVariableOrWriteNode(name_loc, operator_loc, value, location = Location())
+      InstanceVariableOrWriteNode.new(name_loc, operator_loc, value, location)
+    end
+
     # Create a new InstanceVariableReadNode node
     def InstanceVariableReadNode(location = Location())
       InstanceVariableReadNode.new(location)
     end
 
+    # Create a new InstanceVariableTargetNode node
+    def InstanceVariableTargetNode(location = Location())
+      InstanceVariableTargetNode.new(location)
+    end
+
     # Create a new InstanceVariableWriteNode node
     def InstanceVariableWriteNode(name_loc, value, operator_loc, location = Location())
       InstanceVariableWriteNode.new(name_loc, value, operator_loc, location)
@@ -7208,23 +8842,23 @@ 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)
+    def LambdaNode(locals, operator_loc, opening_loc, closing_loc, parameters, body, location = Location())
+      LambdaNode.new(locals, operator_loc, opening_loc, closing_loc, parameters, body, 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)
+    # Create a new LocalVariableAndWriteNode node
+    def LocalVariableAndWriteNode(name_loc, operator_loc, value, constant_id, depth, location = Location())
+      LocalVariableAndWriteNode.new(name_loc, operator_loc, value, constant_id, depth, 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)
+    # Create a new LocalVariableOperatorWriteNode node
+    def LocalVariableOperatorWriteNode(name_loc, operator_loc, value, constant_id, operator_id, depth, location = Location())
+      LocalVariableOperatorWriteNode.new(name_loc, operator_loc, value, constant_id, operator_id, depth, 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)
+    # Create a new LocalVariableOrWriteNode node
+    def LocalVariableOrWriteNode(name_loc, operator_loc, value, constant_id, depth, location = Location())
+      LocalVariableOrWriteNode.new(name_loc, operator_loc, value, constant_id, depth, location)
     end
 
     # Create a new LocalVariableReadNode node
@@ -7232,6 +8866,11 @@ module YARP
       LocalVariableReadNode.new(constant_id, depth, location)
     end
 
+    # Create a new LocalVariableTargetNode node
+    def LocalVariableTargetNode(constant_id, depth, location = Location())
+      LocalVariableTargetNode.new(constant_id, depth, location)
+    end
+
     # Create a new LocalVariableWriteNode node
     def LocalVariableWriteNode(constant_id, depth, value, name_loc, operator_loc, location = Location())
       LocalVariableWriteNode.new(constant_id, depth, value, name_loc, operator_loc, location)
@@ -7253,8 +8892,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, name, location = Location())
+      ModuleNode.new(locals, module_keyword_loc, constant_path, body, end_keyword_loc, name, location)
     end
 
     # Create a new MultiWriteNode node
@@ -7298,8 +8937,8 @@ module YARP
     end
 
     # Create a new ParenthesesNode node
-    def ParenthesesNode(statements, opening_loc, closing_loc, location = Location())
-      ParenthesesNode.new(statements, opening_loc, closing_loc, location)
+    def ParenthesesNode(body, opening_loc, closing_loc, location = Location())
+      ParenthesesNode.new(body, opening_loc, closing_loc, location)
     end
 
     # Create a new PinnedExpressionNode node
@@ -7388,8 +9027,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
@@ -7453,8 +9092,8 @@ module YARP
     end
 
     # Create a new UntilNode node
-    def UntilNode(keyword_loc, predicate, statements, flags, location = Location())
-      UntilNode.new(keyword_loc, predicate, statements, flags, location)
+    def UntilNode(keyword_loc, closing_loc, predicate, statements, flags, location = Location())
+      UntilNode.new(keyword_loc, closing_loc, predicate, statements, flags, location)
     end
 
     # Create a new WhenNode node
@@ -7463,8 +9102,8 @@ module YARP
     end
 
     # Create a new WhileNode node
-    def WhileNode(keyword_loc, predicate, statements, flags, location = Location())
-      WhileNode.new(keyword_loc, predicate, statements, flags, location)
+    def WhileNode(keyword_loc, closing_loc, predicate, statements, flags, location = Location())
+      WhileNode.new(keyword_loc, closing_loc, predicate, statements, flags, location)
     end
 
     # Create a new XStringNode node