yarp 0.9.0 → 0.10.0

data/lib/yarp/node.rb

@@ -1142,15 +1142,15 @@ module YARP
     # attr_reader value: Node
     attr_reader :value
 
-    # attr_reader operator_id: Symbol
-    attr_reader :operator_id
+    # attr_reader operator: Symbol
+    attr_reader :operator
 
-    # def initialize: (target: CallNode, operator_loc: Location, value: Node, operator_id: Symbol, location: Location) -> void
-    def initialize(target, operator_loc, value, operator_id, location)
+    # def initialize: (target: CallNode, 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_id = operator_id
+      @operator = operator
       @location = location
     end
 
@@ -1170,7 +1170,7 @@ module YARP
         params.fetch(:target) { target },
         params.fetch(:operator_loc) { operator_loc },
         params.fetch(:value) { value },
-        params.fetch(:operator_id) { operator_id },
+        params.fetch(:operator) { operator },
         params.fetch(:location) { location },
       )
     end
@@ -1180,12 +1180,7 @@ 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_id: operator_id, 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
 
@@ -1414,6 +1409,9 @@ module YARP
   #     @@target &&= value
   #     ^^^^^^^^^^^^^^^^
   class ClassVariableAndWriteNode < Node
+    # attr_reader name: Symbol
+    attr_reader :name
+
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
@@ -1423,8 +1421,9 @@ 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)
+    # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(name, name_loc, operator_loc, value, location)
+      @name = name
       @name_loc = name_loc
       @operator_loc = operator_loc
       @value = value
@@ -1444,6 +1443,7 @@ module YARP
     # def copy: (**params) -> ClassVariableAndWriteNode
     def copy(**params)
       ClassVariableAndWriteNode.new(
+        params.fetch(:name) { name },
         params.fetch(:name_loc) { name_loc },
         params.fetch(:operator_loc) { operator_loc },
         params.fetch(:value) { value },
@@ -1456,12 +1456,7 @@ module YARP
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
-    end
-
-    # def name: () -> String
-    def name
-      name_loc.slice
+      { name: name, name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
     end
 
     # def operator: () -> String
@@ -1475,6 +1470,9 @@ module YARP
   #     @@target += value
   #     ^^^^^^^^^^^^^^^^^
   class ClassVariableOperatorWriteNode < Node
+    # attr_reader name: Symbol
+    attr_reader :name
+
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
@@ -1487,8 +1485,9 @@ module YARP
     # 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: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void
+    def initialize(name, name_loc, operator_loc, value, operator, location)
+      @name = name
       @name_loc = name_loc
       @operator_loc = operator_loc
       @value = value
@@ -1509,6 +1508,7 @@ module YARP
     # def copy: (**params) -> ClassVariableOperatorWriteNode
     def copy(**params)
       ClassVariableOperatorWriteNode.new(
+        params.fetch(:name) { name },
         params.fetch(:name_loc) { name_loc },
         params.fetch(:operator_loc) { operator_loc },
         params.fetch(:value) { value },
@@ -1522,12 +1522,7 @@ module YARP
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, operator: operator, location: location }
-    end
-
-    # def name: () -> String
-    def name
-      name_loc.slice
+      { name: name, name_loc: name_loc, operator_loc: operator_loc, value: value, operator: operator, location: location }
     end
   end
 
@@ -1536,6 +1531,9 @@ module YARP
   #     @@target ||= value
   #     ^^^^^^^^^^^^^^^^^^
   class ClassVariableOrWriteNode < Node
+    # attr_reader name: Symbol
+    attr_reader :name
+
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
@@ -1545,8 +1543,9 @@ 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)
+    # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(name, name_loc, operator_loc, value, location)
+      @name = name
       @name_loc = name_loc
       @operator_loc = operator_loc
       @value = value
@@ -1566,6 +1565,7 @@ module YARP
     # def copy: (**params) -> ClassVariableOrWriteNode
     def copy(**params)
       ClassVariableOrWriteNode.new(
+        params.fetch(:name) { name },
         params.fetch(:name_loc) { name_loc },
         params.fetch(:operator_loc) { operator_loc },
         params.fetch(:value) { value },
@@ -1578,12 +1578,7 @@ module YARP
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
-    end
-
-    # def name: () -> String
-    def name
-      name_loc.slice
+      { name: name, name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
     end
 
     # def operator: () -> String
@@ -1597,8 +1592,12 @@ module YARP
   #     @@foo
   #     ^^^^^
   class ClassVariableReadNode < Node
-    # def initialize: (location: Location) -> void
-    def initialize(location)
+    # attr_reader name: Symbol
+    attr_reader :name
+
+    # def initialize: (name: Symbol, location: Location) -> void
+    def initialize(name, location)
+      @name = name
       @location = location
     end
 
@@ -1615,6 +1614,7 @@ module YARP
     # def copy: (**params) -> ClassVariableReadNode
     def copy(**params)
       ClassVariableReadNode.new(
+        params.fetch(:name) { name },
         params.fetch(:location) { location },
       )
     end
@@ -1624,7 +1624,7 @@ module YARP
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { location: location }
+      { name: name, location: location }
     end
   end
 
@@ -1633,8 +1633,12 @@ module YARP
   #     @@foo, @@bar = baz
   #     ^^^^^  ^^^^^
   class ClassVariableTargetNode < Node
-    # def initialize: (location: Location) -> void
-    def initialize(location)
+    # attr_reader name: Symbol
+    attr_reader :name
+
+    # def initialize: (name: Symbol, location: Location) -> void
+    def initialize(name, location)
+      @name = name
       @location = location
     end
 
@@ -1651,6 +1655,7 @@ module YARP
     # def copy: (**params) -> ClassVariableTargetNode
     def copy(**params)
       ClassVariableTargetNode.new(
+        params.fetch(:name) { name },
         params.fetch(:location) { location },
       )
     end
@@ -1660,7 +1665,7 @@ module YARP
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { location: location }
+      { name: name, location: location }
     end
   end
 
@@ -1669,6 +1674,9 @@ module YARP
   #     @@foo = 1
   #     ^^^^^^^^^
   class ClassVariableWriteNode < Node
+    # attr_reader name: Symbol
+    attr_reader :name
+
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
@@ -1678,8 +1686,9 @@ module YARP
     # attr_reader operator_loc: Location?
     attr_reader :operator_loc
 
-    # def initialize: (name_loc: Location, value: Node?, operator_loc: Location?, location: Location) -> void
-    def initialize(name_loc, value, operator_loc, location)
+    # def initialize: (name: Symbol, name_loc: Location, value: Node?, operator_loc: Location?, location: Location) -> void
+    def initialize(name, name_loc, value, operator_loc, location)
+      @name = name
       @name_loc = name_loc
       @value = value
       @operator_loc = operator_loc
@@ -1699,6 +1708,7 @@ module YARP
     # def copy: (**params) -> ClassVariableWriteNode
     def copy(**params)
       ClassVariableWriteNode.new(
+        params.fetch(:name) { name },
         params.fetch(:name_loc) { name_loc },
         params.fetch(:value) { value },
         params.fetch(:operator_loc) { operator_loc },
@@ -1711,12 +1721,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, value: value, operator_loc: operator_loc, location: location }
-    end
-
-    # def name: () -> String
-    def name
-      name_loc.slice
+      { name: name, name_loc: name_loc, value: value, operator_loc: operator_loc, location: location }
     end
 
     # def operator: () -> String?
@@ -3509,17 +3514,17 @@ module YARP
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
-    # attr_reader operator_loc: Location
-    attr_reader :operator_loc
-
     # attr_reader value: Node
     attr_reader :value
 
-    # def initialize: (name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(name_loc, operator_loc, value, location)
+    # attr_reader operator_loc: Location
+    attr_reader :operator_loc
+
+    # def initialize: (name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void
+    def initialize(name_loc, value, operator_loc, location)
       @name_loc = name_loc
-      @operator_loc = operator_loc
       @value = value
+      @operator_loc = operator_loc
       @location = location
     end
 
@@ -3537,8 +3542,8 @@ module YARP
     def copy(**params)
       GlobalVariableWriteNode.new(
         params.fetch(:name_loc) { name_loc },
-        params.fetch(:operator_loc) { operator_loc },
         params.fetch(:value) { value },
+        params.fetch(:operator_loc) { operator_loc },
         params.fetch(:location) { location },
       )
     end
@@ -3548,7 +3553,7 @@ module YARP
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
+      { name_loc: name_loc, value: value, operator_loc: operator_loc, location: location }
     end
 
     # def name: () -> String
@@ -3887,6 +3892,9 @@ module YARP
   #     @target &&= value
   #     ^^^^^^^^^^^^^^^^^
   class InstanceVariableAndWriteNode < Node
+    # attr_reader name: Symbol
+    attr_reader :name
+
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
@@ -3896,8 +3904,9 @@ 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)
+    # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(name, name_loc, operator_loc, value, location)
+      @name = name
       @name_loc = name_loc
       @operator_loc = operator_loc
       @value = value
@@ -3917,6 +3926,7 @@ module YARP
     # def copy: (**params) -> InstanceVariableAndWriteNode
     def copy(**params)
       InstanceVariableAndWriteNode.new(
+        params.fetch(:name) { name },
         params.fetch(:name_loc) { name_loc },
         params.fetch(:operator_loc) { operator_loc },
         params.fetch(:value) { value },
@@ -3929,12 +3939,7 @@ module YARP
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
-    end
-
-    # def name: () -> String
-    def name
-      name_loc.slice
+      { name: name, name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
     end
 
     # def operator: () -> String
@@ -3948,6 +3953,9 @@ module YARP
   #     @target += value
   #     ^^^^^^^^^^^^^^^^
   class InstanceVariableOperatorWriteNode < Node
+    # attr_reader name: Symbol
+    attr_reader :name
+
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
@@ -3960,8 +3968,9 @@ module YARP
     # 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: Symbol, name_loc: Location, operator_loc: Location, value: Node, operator: Symbol, location: Location) -> void
+    def initialize(name, name_loc, operator_loc, value, operator, location)
+      @name = name
       @name_loc = name_loc
       @operator_loc = operator_loc
       @value = value
@@ -3982,6 +3991,7 @@ module YARP
     # def copy: (**params) -> InstanceVariableOperatorWriteNode
     def copy(**params)
       InstanceVariableOperatorWriteNode.new(
+        params.fetch(:name) { name },
         params.fetch(:name_loc) { name_loc },
         params.fetch(:operator_loc) { operator_loc },
         params.fetch(:value) { value },
@@ -3995,12 +4005,7 @@ module YARP
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, operator: operator, location: location }
-    end
-
-    # def name: () -> String
-    def name
-      name_loc.slice
+      { name: name, name_loc: name_loc, operator_loc: operator_loc, value: value, operator: operator, location: location }
     end
   end
 
@@ -4009,6 +4014,9 @@ module YARP
   #     @target ||= value
   #     ^^^^^^^^^^^^^^^^^
   class InstanceVariableOrWriteNode < Node
+    # attr_reader name: Symbol
+    attr_reader :name
+
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
@@ -4018,8 +4026,9 @@ 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)
+    # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(name, name_loc, operator_loc, value, location)
+      @name = name
       @name_loc = name_loc
       @operator_loc = operator_loc
       @value = value
@@ -4039,6 +4048,7 @@ module YARP
     # def copy: (**params) -> InstanceVariableOrWriteNode
     def copy(**params)
       InstanceVariableOrWriteNode.new(
+        params.fetch(:name) { name },
         params.fetch(:name_loc) { name_loc },
         params.fetch(:operator_loc) { operator_loc },
         params.fetch(:value) { value },
@@ -4051,12 +4061,7 @@ module YARP
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
-    end
-
-    # def name: () -> String
-    def name
-      name_loc.slice
+      { name: name, name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
     end
 
     # def operator: () -> String
@@ -4070,8 +4075,12 @@ module YARP
   #     @foo
   #     ^^^^
   class InstanceVariableReadNode < Node
-    # def initialize: (location: Location) -> void
-    def initialize(location)
+    # attr_reader name: Symbol
+    attr_reader :name
+
+    # def initialize: (name: Symbol, location: Location) -> void
+    def initialize(name, location)
+      @name = name
       @location = location
     end
 
@@ -4088,6 +4097,7 @@ module YARP
     # def copy: (**params) -> InstanceVariableReadNode
     def copy(**params)
       InstanceVariableReadNode.new(
+        params.fetch(:name) { name },
         params.fetch(:location) { location },
       )
     end
@@ -4097,7 +4107,7 @@ module YARP
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { location: location }
+      { name: name, location: location }
     end
   end
 
@@ -4106,8 +4116,12 @@ module YARP
   #     @foo, @bar = baz
   #     ^^^^  ^^^^
   class InstanceVariableTargetNode < Node
-    # def initialize: (location: Location) -> void
-    def initialize(location)
+    # attr_reader name: Symbol
+    attr_reader :name
+
+    # def initialize: (name: Symbol, location: Location) -> void
+    def initialize(name, location)
+      @name = name
       @location = location
     end
 
@@ -4124,6 +4138,7 @@ module YARP
     # def copy: (**params) -> InstanceVariableTargetNode
     def copy(**params)
       InstanceVariableTargetNode.new(
+        params.fetch(:name) { name },
         params.fetch(:location) { location },
       )
     end
@@ -4133,7 +4148,7 @@ module YARP
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { location: location }
+      { name: name, location: location }
     end
   end
 
@@ -4142,6 +4157,9 @@ module YARP
   #     @foo = 1
   #     ^^^^^^^^
   class InstanceVariableWriteNode < Node
+    # attr_reader name: Symbol
+    attr_reader :name
+
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
@@ -4151,8 +4169,9 @@ module YARP
     # attr_reader operator_loc: Location
     attr_reader :operator_loc
 
-    # def initialize: (name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void
-    def initialize(name_loc, value, operator_loc, location)
+    # def initialize: (name: Symbol, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void
+    def initialize(name, name_loc, value, operator_loc, location)
+      @name = name
       @name_loc = name_loc
       @value = value
       @operator_loc = operator_loc
@@ -4172,6 +4191,7 @@ module YARP
     # def copy: (**params) -> InstanceVariableWriteNode
     def copy(**params)
       InstanceVariableWriteNode.new(
+        params.fetch(:name) { name },
         params.fetch(:name_loc) { name_loc },
         params.fetch(:value) { value },
         params.fetch(:operator_loc) { operator_loc },
@@ -4184,12 +4204,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, value: value, operator_loc: operator_loc, location: location }
-    end
-
-    # def name: () -> String
-    def name
-      name_loc.slice
+      { name: name, name_loc: name_loc, value: value, operator_loc: operator_loc, location: location }
     end
 
     # def operator: () -> String
@@ -4792,18 +4807,18 @@ module YARP
     # attr_reader value: Node
     attr_reader :value
 
-    # attr_reader constant_id: Symbol
-    attr_reader :constant_id
+    # attr_reader name: Symbol
+    attr_reader :name
 
     # 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)
+    # def initialize: (name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location) -> void
+    def initialize(name_loc, operator_loc, value, name, depth, location)
       @name_loc = name_loc
       @operator_loc = operator_loc
       @value = value
-      @constant_id = constant_id
+      @name = name
       @depth = depth
       @location = location
     end
@@ -4824,7 +4839,7 @@ module YARP
         params.fetch(:name_loc) { name_loc },
         params.fetch(:operator_loc) { operator_loc },
         params.fetch(:value) { value },
-        params.fetch(:constant_id) { constant_id },
+        params.fetch(:name) { name },
         params.fetch(:depth) { depth },
         params.fetch(:location) { location },
       )
@@ -4835,12 +4850,7 @@ module YARP
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, constant_id: constant_id, depth: depth, location: location }
-    end
-
-    # def name: () -> String
-    def name
-      name_loc.slice
+      { name_loc: name_loc, operator_loc: operator_loc, value: value, name: name, depth: depth, location: location }
     end
 
     # def operator: () -> String
@@ -4863,22 +4873,22 @@ module YARP
     # attr_reader value: Node
     attr_reader :value
 
-    # attr_reader constant_id: Symbol
-    attr_reader :constant_id
+    # attr_reader name: Symbol
+    attr_reader :name
 
-    # attr_reader operator_id: Symbol
-    attr_reader :operator_id
+    # attr_reader operator: Symbol
+    attr_reader :operator
 
     # 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)
+    # def initialize: (name_loc: Location, operator_loc: Location, value: Node, name: Symbol, operator: Symbol, depth: Integer, location: Location) -> void
+    def initialize(name_loc, operator_loc, value, name, operator, depth, location)
       @name_loc = name_loc
       @operator_loc = operator_loc
       @value = value
-      @constant_id = constant_id
-      @operator_id = operator_id
+      @name = name
+      @operator = operator
       @depth = depth
       @location = location
     end
@@ -4899,8 +4909,8 @@ module YARP
         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(:name) { name },
+        params.fetch(:operator) { operator },
         params.fetch(:depth) { depth },
         params.fetch(:location) { location },
       )
@@ -4911,17 +4921,7 @@ module YARP
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, constant_id: constant_id, operator_id: operator_id, depth: depth, location: location }
-    end
-
-    # def name: () -> String
-    def name
-      name_loc.slice
-    end
-
-    # def operator: () -> String
-    def operator
-      operator_loc.slice
+      { name_loc: name_loc, operator_loc: operator_loc, value: value, name: name, operator: operator, depth: depth, location: location }
     end
   end
 
@@ -4939,18 +4939,18 @@ module YARP
     # attr_reader value: Node
     attr_reader :value
 
-    # attr_reader constant_id: Symbol
-    attr_reader :constant_id
+    # attr_reader name: Symbol
+    attr_reader :name
 
     # 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)
+    # def initialize: (name_loc: Location, operator_loc: Location, value: Node, name: Symbol, depth: Integer, location: Location) -> void
+    def initialize(name_loc, operator_loc, value, name, depth, location)
       @name_loc = name_loc
       @operator_loc = operator_loc
       @value = value
-      @constant_id = constant_id
+      @name = name
       @depth = depth
       @location = location
     end
@@ -4971,7 +4971,7 @@ module YARP
         params.fetch(:name_loc) { name_loc },
         params.fetch(:operator_loc) { operator_loc },
         params.fetch(:value) { value },
-        params.fetch(:constant_id) { constant_id },
+        params.fetch(:name) { name },
         params.fetch(:depth) { depth },
         params.fetch(:location) { location },
       )
@@ -4982,12 +4982,7 @@ module YARP
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name_loc: name_loc, operator_loc: operator_loc, value: value, constant_id: constant_id, depth: depth, location: location }
-    end
-
-    # def name: () -> String
-    def name
-      name_loc.slice
+      { name_loc: name_loc, operator_loc: operator_loc, value: value, name: name, depth: depth, location: location }
     end
 
     # def operator: () -> String
@@ -5003,15 +4998,15 @@ module YARP
   #     foo
   #     ^^^
   class LocalVariableReadNode < Node
-    # attr_reader constant_id: Symbol
-    attr_reader :constant_id
+    # attr_reader name: Symbol
+    attr_reader :name
 
     # 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
+    # def initialize: (name: Symbol, depth: Integer, location: Location) -> void
+    def initialize(name, depth, location)
+      @name = name
       @depth = depth
       @location = location
     end
@@ -5029,7 +5024,7 @@ module YARP
     # def copy: (**params) -> LocalVariableReadNode
     def copy(**params)
       LocalVariableReadNode.new(
-        params.fetch(:constant_id) { constant_id },
+        params.fetch(:name) { name },
         params.fetch(:depth) { depth },
         params.fetch(:location) { location },
       )
@@ -5040,7 +5035,7 @@ module YARP
 
     # 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 }
+      { name: name, depth: depth, location: location }
     end
   end
 
@@ -5049,15 +5044,15 @@ module YARP
   #     foo, bar = baz
   #     ^^^  ^^^
   class LocalVariableTargetNode < Node
-    # attr_reader constant_id: Symbol
-    attr_reader :constant_id
+    # attr_reader name: Symbol
+    attr_reader :name
 
     # 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
+    # def initialize: (name: Symbol, depth: Integer, location: Location) -> void
+    def initialize(name, depth, location)
+      @name = name
       @depth = depth
       @location = location
     end
@@ -5075,7 +5070,7 @@ module YARP
     # def copy: (**params) -> LocalVariableTargetNode
     def copy(**params)
       LocalVariableTargetNode.new(
-        params.fetch(:constant_id) { constant_id },
+        params.fetch(:name) { name },
         params.fetch(:depth) { depth },
         params.fetch(:location) { location },
       )
@@ -5086,7 +5081,7 @@ module YARP
 
     # 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 }
+      { name: name, depth: depth, location: location }
     end
   end
 
@@ -5095,27 +5090,27 @@ module YARP
   #     foo = 1
   #     ^^^^^^^
   class LocalVariableWriteNode < Node
-    # attr_reader constant_id: Symbol
-    attr_reader :constant_id
+    # attr_reader name: Symbol
+    attr_reader :name
 
     # attr_reader depth: Integer
     attr_reader :depth
 
-    # attr_reader value: Node
-    attr_reader :value
-
     # attr_reader name_loc: Location
     attr_reader :name_loc
 
+    # attr_reader value: Node
+    attr_reader :value
+
     # attr_reader operator_loc: Location
     attr_reader :operator_loc
 
-    # def initialize: (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
+    # def initialize: (name: Symbol, depth: Integer, name_loc: Location, value: Node, operator_loc: Location, location: Location) -> void
+    def initialize(name, depth, name_loc, value, operator_loc, location)
+      @name = name
       @depth = depth
-      @value = value
       @name_loc = name_loc
+      @value = value
       @operator_loc = operator_loc
       @location = location
     end
@@ -5133,10 +5128,10 @@ module YARP
     # def copy: (**params) -> LocalVariableWriteNode
     def copy(**params)
       LocalVariableWriteNode.new(
-        params.fetch(:constant_id) { constant_id },
+        params.fetch(:name) { name },
         params.fetch(:depth) { depth },
-        params.fetch(:value) { value },
         params.fetch(:name_loc) { name_loc },
+        params.fetch(:value) { value },
         params.fetch(:operator_loc) { operator_loc },
         params.fetch(:location) { location },
       )
@@ -5147,12 +5142,7 @@ module YARP
 
     # 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, value: value, name_loc: name_loc, operator_loc: operator_loc, location: location }
-    end
-
-    # def name: () -> String
-    def name
-      name_loc.slice
+      { name: name, depth: depth, name_loc: name_loc, value: value, operator_loc: operator_loc, location: location }
     end
 
     # def operator: () -> String
@@ -5608,8 +5598,12 @@ module YARP
   #     $1
   #     ^^
   class NumberedReferenceReadNode < Node
-    # def initialize: (location: Location) -> void
-    def initialize(location)
+    # attr_reader number: Integer
+    attr_reader :number
+
+    # def initialize: (number: Integer, location: Location) -> void
+    def initialize(number, location)
+      @number = number
       @location = location
     end
 
@@ -5626,6 +5620,7 @@ module YARP
     # def copy: (**params) -> NumberedReferenceReadNode
     def copy(**params)
       NumberedReferenceReadNode.new(
+        params.fetch(:number) { number },
         params.fetch(:location) { location },
       )
     end
@@ -5635,7 +5630,7 @@ module YARP
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { location: location }
+      { number: number, location: location }
     end
   end
 
@@ -5645,8 +5640,8 @@ module YARP
   #           ^^^^^
   #     end
   class OptionalParameterNode < Node
-    # attr_reader constant_id: Symbol
-    attr_reader :constant_id
+    # attr_reader name: Symbol
+    attr_reader :name
 
     # attr_reader name_loc: Location
     attr_reader :name_loc
@@ -5657,9 +5652,9 @@ module YARP
     # attr_reader value: Node
     attr_reader :value
 
-    # def initialize: (constant_id: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(constant_id, name_loc, operator_loc, value, location)
-      @constant_id = constant_id
+    # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(name, name_loc, operator_loc, value, location)
+      @name = name
       @name_loc = name_loc
       @operator_loc = operator_loc
       @value = value
@@ -5679,7 +5674,7 @@ module YARP
     # def copy: (**params) -> OptionalParameterNode
     def copy(**params)
       OptionalParameterNode.new(
-        params.fetch(:constant_id) { constant_id },
+        params.fetch(:name) { name },
         params.fetch(:name_loc) { name_loc },
         params.fetch(:operator_loc) { operator_loc },
         params.fetch(:value) { value },
@@ -5692,12 +5687,7 @@ module YARP
 
     # 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, name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
-    end
-
-    # def name: () -> String
-    def name
-      name_loc.slice
+      { name: name, name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
     end
 
     # def operator: () -> String
@@ -6538,12 +6528,12 @@ module YARP
   #           ^
   #     end
   class RequiredParameterNode < Node
-    # attr_reader constant_id: Symbol
-    attr_reader :constant_id
+    # attr_reader name: Symbol
+    attr_reader :name
 
-    # def initialize: (constant_id: Symbol, location: Location) -> void
-    def initialize(constant_id, location)
-      @constant_id = constant_id
+    # def initialize: (name: Symbol, location: Location) -> void
+    def initialize(name, location)
+      @name = name
       @location = location
     end
 
@@ -6560,7 +6550,7 @@ module YARP
     # def copy: (**params) -> RequiredParameterNode
     def copy(**params)
       RequiredParameterNode.new(
-        params.fetch(:constant_id) { constant_id },
+        params.fetch(:name) { name },
         params.fetch(:location) { location },
       )
     end
@@ -6570,7 +6560,7 @@ module YARP
 
     # 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, location: location }
+      { name: name, location: location }
     end
   end
 
@@ -8537,8 +8527,8 @@ module YARP
     end
 
     # Create a new CallOperatorWriteNode node
-    def CallOperatorWriteNode(target, operator_loc, value, operator_id, location = Location())
-      CallOperatorWriteNode.new(target, operator_loc, value, operator_id, location)
+    def CallOperatorWriteNode(target, operator_loc, value, operator, location = Location())
+      CallOperatorWriteNode.new(target, operator_loc, value, operator, location)
     end
 
     # Create a new CapturePatternNode node
@@ -8557,33 +8547,33 @@ module YARP
     end
 
     # Create a new ClassVariableAndWriteNode node
-    def ClassVariableAndWriteNode(name_loc, operator_loc, value, location = Location())
-      ClassVariableAndWriteNode.new(name_loc, operator_loc, value, location)
+    def ClassVariableAndWriteNode(name, name_loc, operator_loc, value, location = Location())
+      ClassVariableAndWriteNode.new(name, name_loc, operator_loc, value, location)
     end
 
     # Create a new ClassVariableOperatorWriteNode node
-    def ClassVariableOperatorWriteNode(name_loc, operator_loc, value, operator, location = Location())
-      ClassVariableOperatorWriteNode.new(name_loc, operator_loc, value, operator, location)
+    def ClassVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = Location())
+      ClassVariableOperatorWriteNode.new(name, 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)
+    def ClassVariableOrWriteNode(name, name_loc, operator_loc, value, location = Location())
+      ClassVariableOrWriteNode.new(name, name_loc, operator_loc, value, location)
     end
 
     # Create a new ClassVariableReadNode node
-    def ClassVariableReadNode(location = Location())
-      ClassVariableReadNode.new(location)
+    def ClassVariableReadNode(name, location = Location())
+      ClassVariableReadNode.new(name, location)
     end
 
     # Create a new ClassVariableTargetNode node
-    def ClassVariableTargetNode(location = Location())
-      ClassVariableTargetNode.new(location)
+    def ClassVariableTargetNode(name, location = Location())
+      ClassVariableTargetNode.new(name, location)
     end
 
     # Create a new ClassVariableWriteNode node
-    def ClassVariableWriteNode(name_loc, value, operator_loc, location = Location())
-      ClassVariableWriteNode.new(name_loc, value, operator_loc, location)
+    def ClassVariableWriteNode(name, name_loc, value, operator_loc, location = Location())
+      ClassVariableWriteNode.new(name, name_loc, value, operator_loc, location)
     end
 
     # Create a new ConstantAndWriteNode node
@@ -8742,8 +8732,8 @@ module YARP
     end
 
     # Create a new GlobalVariableWriteNode node
-    def GlobalVariableWriteNode(name_loc, operator_loc, value, location = Location())
-      GlobalVariableWriteNode.new(name_loc, operator_loc, value, location)
+    def GlobalVariableWriteNode(name_loc, value, operator_loc, location = Location())
+      GlobalVariableWriteNode.new(name_loc, value, operator_loc, location)
     end
 
     # Create a new HashNode node
@@ -8772,33 +8762,33 @@ module YARP
     end
 
     # Create a new InstanceVariableAndWriteNode node
-    def InstanceVariableAndWriteNode(name_loc, operator_loc, value, location = Location())
-      InstanceVariableAndWriteNode.new(name_loc, operator_loc, value, location)
+    def InstanceVariableAndWriteNode(name, name_loc, operator_loc, value, location = Location())
+      InstanceVariableAndWriteNode.new(name, name_loc, operator_loc, value, location)
     end
 
     # Create a new InstanceVariableOperatorWriteNode node
-    def InstanceVariableOperatorWriteNode(name_loc, operator_loc, value, operator, location = Location())
-      InstanceVariableOperatorWriteNode.new(name_loc, operator_loc, value, operator, location)
+    def InstanceVariableOperatorWriteNode(name, name_loc, operator_loc, value, operator, location = Location())
+      InstanceVariableOperatorWriteNode.new(name, 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)
+    def InstanceVariableOrWriteNode(name, name_loc, operator_loc, value, location = Location())
+      InstanceVariableOrWriteNode.new(name, name_loc, operator_loc, value, location)
     end
 
     # Create a new InstanceVariableReadNode node
-    def InstanceVariableReadNode(location = Location())
-      InstanceVariableReadNode.new(location)
+    def InstanceVariableReadNode(name, location = Location())
+      InstanceVariableReadNode.new(name, location)
     end
 
     # Create a new InstanceVariableTargetNode node
-    def InstanceVariableTargetNode(location = Location())
-      InstanceVariableTargetNode.new(location)
+    def InstanceVariableTargetNode(name, location = Location())
+      InstanceVariableTargetNode.new(name, location)
     end
 
     # Create a new InstanceVariableWriteNode node
-    def InstanceVariableWriteNode(name_loc, value, operator_loc, location = Location())
-      InstanceVariableWriteNode.new(name_loc, value, operator_loc, location)
+    def InstanceVariableWriteNode(name, name_loc, value, operator_loc, location = Location())
+      InstanceVariableWriteNode.new(name, name_loc, value, operator_loc, location)
     end
 
     # Create a new IntegerNode node
@@ -8847,33 +8837,33 @@ module YARP
     end
 
     # 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)
+    def LocalVariableAndWriteNode(name_loc, operator_loc, value, name, depth, location = Location())
+      LocalVariableAndWriteNode.new(name_loc, operator_loc, value, name, depth, location)
     end
 
     # 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)
+    def LocalVariableOperatorWriteNode(name_loc, operator_loc, value, name, operator, depth, location = Location())
+      LocalVariableOperatorWriteNode.new(name_loc, operator_loc, value, name, operator, depth, location)
     end
 
     # 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)
+    def LocalVariableOrWriteNode(name_loc, operator_loc, value, name, depth, location = Location())
+      LocalVariableOrWriteNode.new(name_loc, operator_loc, value, name, depth, location)
     end
 
     # Create a new LocalVariableReadNode node
-    def LocalVariableReadNode(constant_id, depth, location = Location())
-      LocalVariableReadNode.new(constant_id, depth, location)
+    def LocalVariableReadNode(name, depth, location = Location())
+      LocalVariableReadNode.new(name, depth, location)
     end
 
     # Create a new LocalVariableTargetNode node
-    def LocalVariableTargetNode(constant_id, depth, location = Location())
-      LocalVariableTargetNode.new(constant_id, depth, location)
+    def LocalVariableTargetNode(name, depth, location = Location())
+      LocalVariableTargetNode.new(name, 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)
+    def LocalVariableWriteNode(name, depth, name_loc, value, operator_loc, location = Location())
+      LocalVariableWriteNode.new(name, depth, name_loc, value, operator_loc, location)
     end
 
     # Create a new MatchPredicateNode node
@@ -8917,13 +8907,13 @@ module YARP
     end
 
     # Create a new NumberedReferenceReadNode node
-    def NumberedReferenceReadNode(location = Location())
-      NumberedReferenceReadNode.new(location)
+    def NumberedReferenceReadNode(number, location = Location())
+      NumberedReferenceReadNode.new(number, location)
     end
 
     # Create a new OptionalParameterNode node
-    def OptionalParameterNode(constant_id, name_loc, operator_loc, value, location = Location())
-      OptionalParameterNode.new(constant_id, name_loc, operator_loc, value, location)
+    def OptionalParameterNode(name, name_loc, operator_loc, value, location = Location())
+      OptionalParameterNode.new(name, name_loc, operator_loc, value, location)
     end
 
     # Create a new OrNode node
@@ -8992,8 +8982,8 @@ module YARP
     end
 
     # Create a new RequiredParameterNode node
-    def RequiredParameterNode(constant_id, location = Location())
-      RequiredParameterNode.new(constant_id, location)
+    def RequiredParameterNode(name, location = Location())
+      RequiredParameterNode.new(name, location)
     end
 
     # Create a new RescueModifierNode node