prism 0.13.0 → 0.15.0

data/lib/prism/node.rb

@@ -130,6 +130,16 @@ module Prism
     def type
       :alias_global_variable_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :alias_global_variable_node
+    end
   end
 
   # Represents the use of the `alias` keyword to alias a method.
@@ -224,6 +234,16 @@ module Prism
     def type
       :alias_method_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :alias_method_node
+    end
   end
 
   # Represents an alternation pattern in pattern matching.
@@ -318,6 +338,16 @@ module Prism
     def type
       :alternation_pattern_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :alternation_pattern_node
+    end
   end
 
   # Represents the use of the `&&` operator or the `and` keyword.
@@ -412,6 +442,16 @@ module Prism
     def type
       :and_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :and_node
+    end
   end
 
   # Represents a set of arguments to a method or a keyword.
@@ -487,6 +527,16 @@ module Prism
     def type
       :arguments_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :arguments_node
+    end
   end
 
   # Represents an array literal. This can be a regular array using brackets or
@@ -585,6 +635,16 @@ module Prism
     def type
       :array_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :array_node
+    end
   end
 
   # Represents an array pattern in pattern matching.
@@ -727,6 +787,16 @@ module Prism
     def type
       :array_pattern_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :array_pattern_node
+    end
   end
 
   # Represents a hash key/value pair.
@@ -828,6 +898,16 @@ module Prism
     def type
       :assoc_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :assoc_node
+    end
   end
 
   # Represents a splat in a hash literal.
@@ -921,6 +1001,16 @@ module Prism
     def type
       :assoc_splat_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :assoc_splat_node
+    end
   end
 
   # Represents reading a reference to a field in the previous match.
@@ -928,8 +1018,12 @@ module Prism
   #     $'
   #     ^^
   class BackReferenceReadNode < 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
 
@@ -956,6 +1050,7 @@ module Prism
     # def copy: (**params) -> BackReferenceReadNode
     def copy(**params)
       BackReferenceReadNode.new(
+        params.fetch(:name) { name },
         params.fetch(:location) { location },
       )
     end
@@ -965,11 +1060,12 @@ module Prism
 
     # 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
 
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
+      inspector << "└── name: #{name.inspect}\n"
       inspector.to_str
     end
 
@@ -990,6 +1086,16 @@ module Prism
     def type
       :back_reference_read_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :back_reference_read_node
+    end
   end
 
   # Represents a begin statement.
@@ -1136,6 +1242,16 @@ module Prism
     def type
       :begin_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :begin_node
+    end
   end
 
   # Represents block method arguments.
@@ -1229,6 +1345,16 @@ module Prism
     def type
       :block_argument_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :block_argument_node
+    end
   end
 
   # Represents a block local variable.
@@ -1304,6 +1430,16 @@ module Prism
     def type
       :block_local_variable_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :block_local_variable_node
+    end
   end
 
   # Represents a block of ruby code.
@@ -1426,6 +1562,16 @@ module Prism
     def type
       :block_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :block_node
+    end
   end
 
   # Represents a block parameter to a method, block, or lambda definition.
@@ -1519,6 +1665,16 @@ module Prism
     def type
       :block_parameter_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :block_parameter_node
+    end
   end
 
   # Represents a block's parameters declaration.
@@ -1634,6 +1790,16 @@ module Prism
     def type
       :block_parameters_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :block_parameters_node
+    end
   end
 
   # Represents the use of the `break` keyword.
@@ -1727,6 +1893,16 @@ module Prism
     def type
       :break_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :break_node
+    end
   end
 
   # Represents the use of the `&&=` operator on a call.
@@ -1743,22 +1919,13 @@ module Prism
     # attr_reader message_loc: Location?
     attr_reader :message_loc
 
-    # attr_reader opening_loc: Location?
-    attr_reader :opening_loc
-
-    # attr_reader arguments: ArgumentsNode?
-    attr_reader :arguments
-
-    # attr_reader closing_loc: Location?
-    attr_reader :closing_loc
-
     # attr_reader flags: Integer
     private attr_reader :flags
 
-    # attr_reader read_name: String
+    # attr_reader read_name: Symbol
     attr_reader :read_name
 
-    # attr_reader write_name: String
+    # attr_reader write_name: Symbol
     attr_reader :write_name
 
     # attr_reader operator_loc: Location
@@ -1767,14 +1934,11 @@ module Prism
     # attr_reader value: Node
     attr_reader :value
 
-    # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, flags: Integer, read_name: String, write_name: String, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location)
+    # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, flags: Integer, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator_loc, value, location)
       @receiver = receiver
       @call_operator_loc = call_operator_loc
       @message_loc = message_loc
-      @opening_loc = opening_loc
-      @arguments = arguments
-      @closing_loc = closing_loc
       @flags = flags
       @read_name = read_name
       @write_name = write_name
@@ -1790,21 +1954,20 @@ module Prism
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [receiver, arguments, value]
+      [receiver, value]
     end
 
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = []
       compact << receiver if receiver
-      compact << arguments if arguments
       compact << value
       compact
     end
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [*receiver, *call_operator_loc, *message_loc, *opening_loc, *arguments, *closing_loc, operator_loc, value]
+      [*receiver, *call_operator_loc, *message_loc, operator_loc, value]
     end
 
     # def copy: (**params) -> CallAndWriteNode
@@ -1813,9 +1976,6 @@ module Prism
         params.fetch(:receiver) { receiver },
         params.fetch(:call_operator_loc) { call_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(:flags) { flags },
         params.fetch(:read_name) { read_name },
         params.fetch(:write_name) { write_name },
@@ -1830,7 +1990,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, flags: flags, read_name: read_name, write_name: write_name, operator_loc: operator_loc, value: value, location: location }
+      { receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, flags: flags, read_name: read_name, write_name: write_name, operator_loc: operator_loc, value: value, location: location }
     end
 
     # def call_operator: () -> String?
@@ -1843,16 +2003,6 @@ module Prism
       message_loc&.slice
     end
 
-    # def opening: () -> String?
-    def opening
-      opening_loc&.slice
-    end
-
-    # def closing: () -> String?
-    def closing
-      closing_loc&.slice
-    end
-
     # def safe_navigation?: () -> bool
     def safe_navigation?
       flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -1878,14 +2028,6 @@ module Prism
       end
       inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
       inspector << "├── message_loc: #{inspector.location(message_loc)}\n"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      if (arguments = self.arguments).nil?
-        inspector << "├── arguments: ∅\n"
-      else
-        inspector << "├── arguments:\n"
-        inspector << arguments.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
       flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
       inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector << "├── read_name: #{read_name.inspect}\n"
@@ -1913,6 +2055,16 @@ module Prism
     def type
       :call_and_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :call_and_write_node
+    end
   end
 
   # Represents a method call, in all of the various forms that can take.
@@ -1959,10 +2111,10 @@ module Prism
     # attr_reader flags: Integer
     private attr_reader :flags
 
-    # attr_reader name: String
+    # attr_reader name: Symbol
     attr_reader :name
 
-    # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: Node?, flags: Integer, name: String, location: Location) -> void
+    # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: Node?, flags: Integer, name: Symbol, location: Location) -> void
     def initialize(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, block, flags, name, location)
       @receiver = receiver
       @call_operator_loc = call_operator_loc
@@ -2101,6 +2253,16 @@ module Prism
     def type
       :call_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :call_node
+    end
   end
 
   # Represents the use of an assignment operator on a call.
@@ -2117,22 +2279,13 @@ module Prism
     # attr_reader message_loc: Location?
     attr_reader :message_loc
 
-    # attr_reader opening_loc: Location?
-    attr_reader :opening_loc
-
-    # attr_reader arguments: ArgumentsNode?
-    attr_reader :arguments
-
-    # attr_reader closing_loc: Location?
-    attr_reader :closing_loc
-
     # attr_reader flags: Integer
     private attr_reader :flags
 
-    # attr_reader read_name: String
+    # attr_reader read_name: Symbol
     attr_reader :read_name
 
-    # attr_reader write_name: String
+    # attr_reader write_name: Symbol
     attr_reader :write_name
 
     # attr_reader operator: Symbol
@@ -2144,14 +2297,11 @@ module Prism
     # attr_reader value: Node
     attr_reader :value
 
-    # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, flags: Integer, read_name: String, write_name: String, operator: Symbol, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator, operator_loc, value, location)
+    # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, flags: Integer, read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator, operator_loc, value, location)
       @receiver = receiver
       @call_operator_loc = call_operator_loc
       @message_loc = message_loc
-      @opening_loc = opening_loc
-      @arguments = arguments
-      @closing_loc = closing_loc
       @flags = flags
       @read_name = read_name
       @write_name = write_name
@@ -2168,21 +2318,20 @@ module Prism
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [receiver, arguments, value]
+      [receiver, value]
     end
 
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = []
       compact << receiver if receiver
-      compact << arguments if arguments
       compact << value
       compact
     end
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [*receiver, *call_operator_loc, *message_loc, *opening_loc, *arguments, *closing_loc, operator_loc, value]
+      [*receiver, *call_operator_loc, *message_loc, operator_loc, value]
     end
 
     # def copy: (**params) -> CallOperatorWriteNode
@@ -2191,9 +2340,6 @@ module Prism
         params.fetch(:receiver) { receiver },
         params.fetch(:call_operator_loc) { call_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(:flags) { flags },
         params.fetch(:read_name) { read_name },
         params.fetch(:write_name) { write_name },
@@ -2209,7 +2355,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, flags: flags, read_name: read_name, write_name: write_name, operator: operator, operator_loc: operator_loc, value: value, location: location }
+      { receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, flags: flags, read_name: read_name, write_name: write_name, operator: operator, operator_loc: operator_loc, value: value, location: location }
     end
 
     # def call_operator: () -> String?
@@ -2222,16 +2368,6 @@ module Prism
       message_loc&.slice
     end
 
-    # def opening: () -> String?
-    def opening
-      opening_loc&.slice
-    end
-
-    # def closing: () -> String?
-    def closing
-      closing_loc&.slice
-    end
-
     # def safe_navigation?: () -> bool
     def safe_navigation?
       flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -2252,14 +2388,6 @@ module Prism
       end
       inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
       inspector << "├── message_loc: #{inspector.location(message_loc)}\n"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      if (arguments = self.arguments).nil?
-        inspector << "├── arguments: ∅\n"
-      else
-        inspector << "├── arguments:\n"
-        inspector << arguments.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
       flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
       inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector << "├── read_name: #{read_name.inspect}\n"
@@ -2288,6 +2416,16 @@ module Prism
     def type
       :call_operator_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :call_operator_write_node
+    end
   end
 
   # Represents the use of the `||=` operator on a call.
@@ -2304,22 +2442,13 @@ module Prism
     # attr_reader message_loc: Location?
     attr_reader :message_loc
 
-    # attr_reader opening_loc: Location?
-    attr_reader :opening_loc
-
-    # attr_reader arguments: ArgumentsNode?
-    attr_reader :arguments
-
-    # attr_reader closing_loc: Location?
-    attr_reader :closing_loc
-
     # attr_reader flags: Integer
     private attr_reader :flags
 
-    # attr_reader read_name: String
+    # attr_reader read_name: Symbol
     attr_reader :read_name
 
-    # attr_reader write_name: String
+    # attr_reader write_name: Symbol
     attr_reader :write_name
 
     # attr_reader operator_loc: Location
@@ -2328,14 +2457,11 @@ module Prism
     # attr_reader value: Node
     attr_reader :value
 
-    # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, flags: Integer, read_name: String, write_name: String, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location)
+    # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, flags: Integer, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator_loc, value, location)
       @receiver = receiver
       @call_operator_loc = call_operator_loc
       @message_loc = message_loc
-      @opening_loc = opening_loc
-      @arguments = arguments
-      @closing_loc = closing_loc
       @flags = flags
       @read_name = read_name
       @write_name = write_name
@@ -2351,21 +2477,20 @@ module Prism
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [receiver, arguments, value]
+      [receiver, value]
     end
 
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = []
       compact << receiver if receiver
-      compact << arguments if arguments
       compact << value
       compact
     end
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [*receiver, *call_operator_loc, *message_loc, *opening_loc, *arguments, *closing_loc, operator_loc, value]
+      [*receiver, *call_operator_loc, *message_loc, operator_loc, value]
     end
 
     # def copy: (**params) -> CallOrWriteNode
@@ -2374,9 +2499,6 @@ module Prism
         params.fetch(:receiver) { receiver },
         params.fetch(:call_operator_loc) { call_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(:flags) { flags },
         params.fetch(:read_name) { read_name },
         params.fetch(:write_name) { write_name },
@@ -2391,7 +2513,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, flags: flags, read_name: read_name, write_name: write_name, operator_loc: operator_loc, value: value, location: location }
+      { receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, flags: flags, read_name: read_name, write_name: write_name, operator_loc: operator_loc, value: value, location: location }
     end
 
     # def call_operator: () -> String?
@@ -2404,16 +2526,6 @@ module Prism
       message_loc&.slice
     end
 
-    # def opening: () -> String?
-    def opening
-      opening_loc&.slice
-    end
-
-    # def closing: () -> String?
-    def closing
-      closing_loc&.slice
-    end
-
     # def safe_navigation?: () -> bool
     def safe_navigation?
       flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -2439,14 +2551,6 @@ module Prism
       end
       inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
       inspector << "├── message_loc: #{inspector.location(message_loc)}\n"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      if (arguments = self.arguments).nil?
-        inspector << "├── arguments: ∅\n"
-      else
-        inspector << "├── arguments:\n"
-        inspector << arguments.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
       flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
       inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector << "├── read_name: #{read_name.inspect}\n"
@@ -2474,6 +2578,16 @@ module Prism
     def type
       :call_or_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :call_or_write_node
+    end
   end
 
   # Represents assigning to a local variable in pattern matching.
@@ -2568,6 +2682,16 @@ module Prism
     def type
       :capture_pattern_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :capture_pattern_node
+    end
   end
 
   # Represents the use of a case statement.
@@ -2693,6 +2817,16 @@ module Prism
     def type
       :case_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :case_node
+    end
   end
 
   # Represents a class declaration involving the `class` keyword.
@@ -2840,6 +2974,16 @@ module Prism
     def type
       :class_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :class_node
+    end
   end
 
   # Represents the use of the `&&=` operator for assignment to a class variable.
@@ -2939,6 +3083,16 @@ module Prism
     def type
       :class_variable_and_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :class_variable_and_write_node
+    end
   end
 
   # Represents assigning to a class variable using an operator that isn't `=`.
@@ -3039,6 +3193,16 @@ module Prism
     def type
       :class_variable_operator_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :class_variable_operator_write_node
+    end
   end
 
   # Represents the use of the `||=` operator for assignment to a class variable.
@@ -3138,6 +3302,16 @@ module Prism
     def type
       :class_variable_or_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :class_variable_or_write_node
+    end
   end
 
   # Represents referencing a class variable.
@@ -3213,6 +3387,16 @@ module Prism
     def type
       :class_variable_read_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :class_variable_read_node
+    end
   end
 
   # Represents writing to a class variable in a context that doesn't have an explicit value.
@@ -3288,6 +3472,16 @@ module Prism
     def type
       :class_variable_target_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :class_variable_target_node
+    end
   end
 
   # Represents writing to a class variable.
@@ -3387,6 +3581,16 @@ module Prism
     def type
       :class_variable_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :class_variable_write_node
+    end
   end
 
   # Represents the use of the `&&=` operator for assignment to a constant.
@@ -3486,6 +3690,16 @@ module Prism
     def type
       :constant_and_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :constant_and_write_node
+    end
   end
 
   # Represents assigning to a constant using an operator that isn't `=`.
@@ -3586,6 +3800,16 @@ module Prism
     def type
       :constant_operator_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :constant_operator_write_node
+    end
   end
 
   # Represents the use of the `||=` operator for assignment to a constant.
@@ -3685,6 +3909,16 @@ module Prism
     def type
       :constant_or_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :constant_or_write_node
+    end
   end
 
   # Represents the use of the `&&=` operator for assignment to a constant path.
@@ -3779,6 +4013,16 @@ module Prism
     def type
       :constant_path_and_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :constant_path_and_write_node
+    end
   end
 
   # Represents accessing a constant through a path of `::` operators.
@@ -3880,6 +4124,16 @@ module Prism
     def type
       :constant_path_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :constant_path_node
+    end
   end
 
   # Represents assigning to a constant path using an operator that isn't `=`.
@@ -3975,7 +4229,17 @@ module Prism
     def type
       :constant_path_operator_write_node
     end
-  end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :constant_path_operator_write_node
+    end
+  end
 
   # Represents the use of the `||=` operator for assignment to a constant path.
   #
@@ -4069,6 +4333,16 @@ module Prism
     def type
       :constant_path_or_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :constant_path_or_write_node
+    end
   end
 
   # Represents writing to a constant path in a context that doesn't have an explicit value.
@@ -4170,6 +4444,16 @@ module Prism
     def type
       :constant_path_target_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :constant_path_target_node
+    end
   end
 
   # Represents writing to a constant path.
@@ -4270,6 +4554,16 @@ module Prism
     def type
       :constant_path_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :constant_path_write_node
+    end
   end
 
   # Represents referencing a constant.
@@ -4345,6 +4639,16 @@ module Prism
     def type
       :constant_read_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :constant_read_node
+    end
   end
 
   # Represents writing to a constant in a context that doesn't have an explicit value.
@@ -4420,6 +4724,16 @@ module Prism
     def type
       :constant_target_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :constant_target_node
+    end
   end
 
   # Represents writing to a constant.
@@ -4519,6 +4833,16 @@ module Prism
     def type
       :constant_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :constant_write_node
+    end
   end
 
   # Represents a method definition.
@@ -4710,6 +5034,16 @@ module Prism
     def type
       :def_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :def_node
+    end
   end
 
   # Represents the use of the `defined?` keyword.
@@ -4819,6 +5153,16 @@ module Prism
     def type
       :defined_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :defined_node
+    end
   end
 
   # Represents an `else` clause in a `case`, `if`, or `unless` statement.
@@ -4923,6 +5267,16 @@ module Prism
     def type
       :else_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :else_node
+    end
   end
 
   # Represents an interpolated set of statements.
@@ -5027,6 +5381,16 @@ module Prism
     def type
       :embedded_statements_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :embedded_statements_node
+    end
   end
 
   # Represents an interpolated variable.
@@ -5114,6 +5478,16 @@ module Prism
     def type
       :embedded_variable_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :embedded_variable_node
+    end
   end
 
   # Represents an `ensure` clause in a `begin` statement.
@@ -5222,6 +5596,16 @@ module Prism
     def type
       :ensure_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :ensure_node
+    end
   end
 
   # Represents the use of the literal `false` keyword.
@@ -5291,6 +5675,16 @@ module Prism
     def type
       :false_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :false_node
+    end
   end
 
   # Represents a find pattern in pattern matching.
@@ -5424,6 +5818,16 @@ module Prism
     def type
       :find_pattern_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :find_pattern_node
+    end
   end
 
   # Represents the use of the `..` or `...` operators to create flip flops.
@@ -5541,6 +5945,16 @@ module Prism
     def type
       :flip_flop_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :flip_flop_node
+    end
   end
 
   # Represents a floating point number literal.
@@ -5610,6 +6024,16 @@ module Prism
     def type
       :float_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :float_node
+    end
   end
 
   # Represents the use of the `for` keyword.
@@ -5752,6 +6176,16 @@ module Prism
     def type
       :for_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :for_node
+    end
   end
 
   # Represents forwarding all arguments to this method to another method.
@@ -5823,6 +6257,16 @@ module Prism
     def type
       :forwarding_arguments_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :forwarding_arguments_node
+    end
   end
 
   # Represents the use of the forwarding parameter in a method, block, or lambda declaration.
@@ -5893,6 +6337,16 @@ module Prism
     def type
       :forwarding_parameter_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :forwarding_parameter_node
+    end
   end
 
   # Represents the use of the `super` keyword without parentheses or arguments.
@@ -5975,6 +6429,16 @@ module Prism
     def type
       :forwarding_super_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :forwarding_super_node
+    end
   end
 
   # Represents the use of the `&&=` operator for assignment to a global variable.
@@ -6074,6 +6538,16 @@ module Prism
     def type
       :global_variable_and_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :global_variable_and_write_node
+    end
   end
 
   # Represents assigning to a global variable using an operator that isn't `=`.
@@ -6174,6 +6648,16 @@ module Prism
     def type
       :global_variable_operator_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :global_variable_operator_write_node
+    end
   end
 
   # Represents the use of the `||=` operator for assignment to a global variable.
@@ -6273,6 +6757,16 @@ module Prism
     def type
       :global_variable_or_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :global_variable_or_write_node
+    end
   end
 
   # Represents referencing a global variable.
@@ -6348,6 +6842,16 @@ module Prism
     def type
       :global_variable_read_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :global_variable_read_node
+    end
   end
 
   # Represents writing to a global variable in a context that doesn't have an explicit value.
@@ -6423,6 +6927,16 @@ module Prism
     def type
       :global_variable_target_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :global_variable_target_node
+    end
   end
 
   # Represents writing to a global variable.
@@ -6522,6 +7036,16 @@ module Prism
     def type
       :global_variable_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :global_variable_write_node
+    end
   end
 
   # Represents a hash literal.
@@ -6619,6 +7143,16 @@ module Prism
     def type
       :hash_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :hash_node
+    end
   end
 
   # Represents a hash pattern in pattern matching.
@@ -6745,6 +7279,16 @@ module Prism
     def type
       :hash_pattern_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :hash_pattern_node
+    end
   end
 
   # Represents the use of the `if` keyword, either in the block form or the modifier form.
@@ -6876,6 +7420,16 @@ module Prism
     def type
       :if_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :if_node
+    end
   end
 
   # Represents an imaginary number literal.
@@ -6952,6 +7506,16 @@ module Prism
     def type
       :imaginary_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :imaginary_node
+    end
   end
 
   # Represents a node that is implicitly being added to the tree but doesn't
@@ -7032,6 +7596,16 @@ module Prism
     def type
       :implicit_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :implicit_node
+    end
   end
 
   # Represents the use of the `in` keyword in a case statement.
@@ -7144,18 +7718,43 @@ module Prism
     def type
       :in_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :in_node
+    end
   end
 
-  # Represents the use of the `&&=` operator for assignment to an instance variable.
+  # Represents the use of the `&&=` operator on a call to the `[]` method.
   #
-  #     @target &&= value
-  #     ^^^^^^^^^^^^^^^^^
-  class InstanceVariableAndWriteNode < Node
-    # attr_reader name: Symbol
-    attr_reader :name
+  #     foo.bar[baz] &&= value
+  #     ^^^^^^^^^^^^^^^^^^^^^^
+  class IndexAndWriteNode < Node
+    # attr_reader receiver: Node?
+    attr_reader :receiver
 
-    # attr_reader name_loc: Location
-    attr_reader :name_loc
+    # attr_reader call_operator_loc: Location?
+    attr_reader :call_operator_loc
+
+    # attr_reader opening_loc: Location
+    attr_reader :opening_loc
+
+    # attr_reader arguments: ArgumentsNode?
+    attr_reader :arguments
+
+    # attr_reader closing_loc: Location
+    attr_reader :closing_loc
+
+    # attr_reader block: Node?
+    attr_reader :block
+
+    # attr_reader flags: Integer
+    private attr_reader :flags
 
     # attr_reader operator_loc: Location
     attr_reader :operator_loc
@@ -7163,10 +7762,15 @@ module Prism
     # attr_reader value: Node
     attr_reader :value
 
-    # 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
+    # def initialize: (receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, flags: Integer, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator_loc, value, location)
+      @receiver = receiver
+      @call_operator_loc = call_operator_loc
+      @opening_loc = opening_loc
+      @arguments = arguments
+      @closing_loc = closing_loc
+      @block = block
+      @flags = flags
       @operator_loc = operator_loc
       @value = value
       @location = location
@@ -7174,29 +7778,39 @@ module Prism
 
     # def accept: (visitor: Visitor) -> void
     def accept(visitor)
-      visitor.visit_instance_variable_and_write_node(self)
+      visitor.visit_index_and_write_node(self)
     end
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [value]
+      [receiver, arguments, block, value]
     end
 
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
-      [value]
+      compact = []
+      compact << receiver if receiver
+      compact << arguments if arguments
+      compact << block if block
+      compact << value
+      compact
     end
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [name_loc, operator_loc, value]
+      [*receiver, *call_operator_loc, opening_loc, *arguments, closing_loc, *block, operator_loc, value]
     end
 
-    # def copy: (**params) -> InstanceVariableAndWriteNode
+    # def copy: (**params) -> IndexAndWriteNode
     def copy(**params)
-      InstanceVariableAndWriteNode.new(
-        params.fetch(:name) { name },
-        params.fetch(:name_loc) { name_loc },
+      IndexAndWriteNode.new(
+        params.fetch(:receiver) { receiver },
+        params.fetch(:call_operator_loc) { call_operator_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(:operator_loc) { operator_loc },
         params.fetch(:value) { value },
         params.fetch(:location) { location },
@@ -7208,7 +7822,32 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { name: name, name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
+      { receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, flags: flags, operator_loc: operator_loc, value: value, location: location }
+    end
+
+    # def call_operator: () -> String?
+    def call_operator
+      call_operator_loc&.slice
+    end
+
+    # def opening: () -> String
+    def opening
+      opening_loc.slice
+    end
+
+    # def closing: () -> String
+    def closing
+      closing_loc.slice
+    end
+
+    # def safe_navigation?: () -> bool
+    def safe_navigation?
+      flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
+    end
+
+    # def variable_call?: () -> bool
+    def variable_call?
+      flags.anybits?(CallNodeFlags::VARIABLE_CALL)
     end
 
     # def operator: () -> String
@@ -7218,8 +7857,29 @@ module Prism
 
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
-      inspector << "├── name: #{name.inspect}\n"
-      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
+      if (receiver = self.receiver).nil?
+        inspector << "├── receiver: ∅\n"
+      else
+        inspector << "├── receiver:\n"
+        inspector << receiver.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
+      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
+      if (arguments = self.arguments).nil?
+        inspector << "├── arguments: ∅\n"
+      else
+        inspector << "├── arguments:\n"
+        inspector << arguments.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
+      if (block = self.block).nil?
+        inspector << "├── block: ∅\n"
+      else
+        inspector << "├── block:\n"
+        inspector << block.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
       inspector << "└── value:\n"
       inspector << inspector.child_node(value, "    ")
@@ -7241,17 +7901,507 @@ module Prism
     #
     # def type: () -> Symbol
     def type
-      :instance_variable_and_write_node
+      :index_and_write_node
+    end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :index_and_write_node
     end
   end
 
-  # Represents assigning to an instance variable using an operator that isn't `=`.
+  # Represents the use of an assignment operator on a call to `[]`.
   #
-  #     @target += value
-  #     ^^^^^^^^^^^^^^^^
-  class InstanceVariableOperatorWriteNode < Node
-    # attr_reader name: Symbol
-    attr_reader :name
+  #     foo.bar[baz] += value
+  #     ^^^^^^^^^^^^^^^^^^^^^
+  class IndexOperatorWriteNode < Node
+    # attr_reader receiver: Node?
+    attr_reader :receiver
+
+    # attr_reader call_operator_loc: Location?
+    attr_reader :call_operator_loc
+
+    # attr_reader opening_loc: Location
+    attr_reader :opening_loc
+
+    # attr_reader arguments: ArgumentsNode?
+    attr_reader :arguments
+
+    # attr_reader closing_loc: Location
+    attr_reader :closing_loc
+
+    # attr_reader block: Node?
+    attr_reader :block
+
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
+    # attr_reader operator: Symbol
+    attr_reader :operator
+
+    # attr_reader operator_loc: Location
+    attr_reader :operator_loc
+
+    # attr_reader value: Node
+    attr_reader :value
+
+    # def initialize: (receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, flags: Integer, operator: Symbol, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator, operator_loc, value, location)
+      @receiver = receiver
+      @call_operator_loc = call_operator_loc
+      @opening_loc = opening_loc
+      @arguments = arguments
+      @closing_loc = closing_loc
+      @block = block
+      @flags = flags
+      @operator = operator
+      @operator_loc = operator_loc
+      @value = value
+      @location = location
+    end
+
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_index_operator_write_node(self)
+    end
+
+    # def child_nodes: () -> Array[nil | Node]
+    def child_nodes
+      [receiver, arguments, block, value]
+    end
+
+    # def compact_child_nodes: () -> Array[Node]
+    def compact_child_nodes
+      compact = []
+      compact << receiver if receiver
+      compact << arguments if arguments
+      compact << block if block
+      compact << value
+      compact
+    end
+
+    # def comment_targets: () -> Array[Node | Location]
+    def comment_targets
+      [*receiver, *call_operator_loc, opening_loc, *arguments, closing_loc, *block, operator_loc, value]
+    end
+
+    # def copy: (**params) -> IndexOperatorWriteNode
+    def copy(**params)
+      IndexOperatorWriteNode.new(
+        params.fetch(:receiver) { receiver },
+        params.fetch(:call_operator_loc) { call_operator_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(:operator) { operator },
+        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)
+      { receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, flags: flags, operator: operator, operator_loc: operator_loc, value: value, location: location }
+    end
+
+    # def call_operator: () -> String?
+    def call_operator
+      call_operator_loc&.slice
+    end
+
+    # def opening: () -> String
+    def opening
+      opening_loc.slice
+    end
+
+    # def closing: () -> String
+    def closing
+      closing_loc.slice
+    end
+
+    # def safe_navigation?: () -> bool
+    def safe_navigation?
+      flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
+    end
+
+    # def variable_call?: () -> bool
+    def variable_call?
+      flags.anybits?(CallNodeFlags::VARIABLE_CALL)
+    end
+
+    def inspect(inspector = NodeInspector.new)
+      inspector << inspector.header(self)
+      if (receiver = self.receiver).nil?
+        inspector << "├── receiver: ∅\n"
+      else
+        inspector << "├── receiver:\n"
+        inspector << receiver.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
+      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
+      if (arguments = self.arguments).nil?
+        inspector << "├── arguments: ∅\n"
+      else
+        inspector << "├── arguments:\n"
+        inspector << arguments.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
+      if (block = self.block).nil?
+        inspector << "├── block: ∅\n"
+      else
+        inspector << "├── block:\n"
+        inspector << block.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
+      inspector << "├── operator: #{operator.inspect}\n"
+      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
+      inspector << "└── value:\n"
+      inspector << inspector.child_node(value, "    ")
+      inspector.to_str
+    end
+
+    # Sometimes you want to check an instance of a node against a list of
+    # classes to see what kind of behavior to perform. Usually this is done by
+    # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+    # case statement and doing `case node; when cls1; when cls2; end`. Both of
+    # these approaches are relatively slow because of the constant lookups,
+    # method calls, and/or array allocations.
+    #
+    # Instead, you can call #type, which will return to you a symbol that you
+    # can use for comparison. This is faster than the other approaches because
+    # it uses a single integer comparison, but also because if you're on CRuby
+    # you can take advantage of the fact that case statements with all symbol
+    # keys will use a jump table.
+    #
+    # def type: () -> Symbol
+    def type
+      :index_operator_write_node
+    end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :index_operator_write_node
+    end
+  end
+
+  # Represents the use of the `||=` operator on a call to `[]`.
+  #
+  #     foo.bar[baz] ||= value
+  #     ^^^^^^^^^^^^^^^^^^^^^^
+  class IndexOrWriteNode < Node
+    # attr_reader receiver: Node?
+    attr_reader :receiver
+
+    # attr_reader call_operator_loc: Location?
+    attr_reader :call_operator_loc
+
+    # attr_reader opening_loc: Location
+    attr_reader :opening_loc
+
+    # attr_reader arguments: ArgumentsNode?
+    attr_reader :arguments
+
+    # attr_reader closing_loc: Location
+    attr_reader :closing_loc
+
+    # attr_reader block: Node?
+    attr_reader :block
+
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
+    # attr_reader operator_loc: Location
+    attr_reader :operator_loc
+
+    # attr_reader value: Node
+    attr_reader :value
+
+    # def initialize: (receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, flags: Integer, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator_loc, value, location)
+      @receiver = receiver
+      @call_operator_loc = call_operator_loc
+      @opening_loc = opening_loc
+      @arguments = arguments
+      @closing_loc = closing_loc
+      @block = block
+      @flags = flags
+      @operator_loc = operator_loc
+      @value = value
+      @location = location
+    end
+
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_index_or_write_node(self)
+    end
+
+    # def child_nodes: () -> Array[nil | Node]
+    def child_nodes
+      [receiver, arguments, block, value]
+    end
+
+    # def compact_child_nodes: () -> Array[Node]
+    def compact_child_nodes
+      compact = []
+      compact << receiver if receiver
+      compact << arguments if arguments
+      compact << block if block
+      compact << value
+      compact
+    end
+
+    # def comment_targets: () -> Array[Node | Location]
+    def comment_targets
+      [*receiver, *call_operator_loc, opening_loc, *arguments, closing_loc, *block, operator_loc, value]
+    end
+
+    # def copy: (**params) -> IndexOrWriteNode
+    def copy(**params)
+      IndexOrWriteNode.new(
+        params.fetch(:receiver) { receiver },
+        params.fetch(:call_operator_loc) { call_operator_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(: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)
+      { receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, flags: flags, operator_loc: operator_loc, value: value, location: location }
+    end
+
+    # def call_operator: () -> String?
+    def call_operator
+      call_operator_loc&.slice
+    end
+
+    # def opening: () -> String
+    def opening
+      opening_loc.slice
+    end
+
+    # def closing: () -> String
+    def closing
+      closing_loc.slice
+    end
+
+    # def safe_navigation?: () -> bool
+    def safe_navigation?
+      flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
+    end
+
+    # def variable_call?: () -> bool
+    def variable_call?
+      flags.anybits?(CallNodeFlags::VARIABLE_CALL)
+    end
+
+    # def operator: () -> String
+    def operator
+      operator_loc.slice
+    end
+
+    def inspect(inspector = NodeInspector.new)
+      inspector << inspector.header(self)
+      if (receiver = self.receiver).nil?
+        inspector << "├── receiver: ∅\n"
+      else
+        inspector << "├── receiver:\n"
+        inspector << receiver.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
+      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
+      if (arguments = self.arguments).nil?
+        inspector << "├── arguments: ∅\n"
+      else
+        inspector << "├── arguments:\n"
+        inspector << arguments.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
+      if (block = self.block).nil?
+        inspector << "├── block: ∅\n"
+      else
+        inspector << "├── block:\n"
+        inspector << block.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
+      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
+      inspector << "└── value:\n"
+      inspector << inspector.child_node(value, "    ")
+      inspector.to_str
+    end
+
+    # Sometimes you want to check an instance of a node against a list of
+    # classes to see what kind of behavior to perform. Usually this is done by
+    # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+    # case statement and doing `case node; when cls1; when cls2; end`. Both of
+    # these approaches are relatively slow because of the constant lookups,
+    # method calls, and/or array allocations.
+    #
+    # Instead, you can call #type, which will return to you a symbol that you
+    # can use for comparison. This is faster than the other approaches because
+    # it uses a single integer comparison, but also because if you're on CRuby
+    # you can take advantage of the fact that case statements with all symbol
+    # keys will use a jump table.
+    #
+    # def type: () -> Symbol
+    def type
+      :index_or_write_node
+    end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :index_or_write_node
+    end
+  end
+
+  # Represents the use of the `&&=` operator for assignment to an instance variable.
+  #
+  #     @target &&= value
+  #     ^^^^^^^^^^^^^^^^^
+  class InstanceVariableAndWriteNode < Node
+    # attr_reader name: Symbol
+    attr_reader :name
+
+    # 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: 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
+      @location = location
+    end
+
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_instance_variable_and_write_node(self)
+    end
+
+    # def child_nodes: () -> Array[nil | Node]
+    def child_nodes
+      [value]
+    end
+
+    # def compact_child_nodes: () -> Array[Node]
+    def compact_child_nodes
+      [value]
+    end
+
+    # def comment_targets: () -> Array[Node | Location]
+    def comment_targets
+      [name_loc, operator_loc, value]
+    end
+
+    # 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 },
+        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: name, name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
+    end
+
+    # def operator: () -> String
+    def operator
+      operator_loc.slice
+    end
+
+    def inspect(inspector = NodeInspector.new)
+      inspector << inspector.header(self)
+      inspector << "├── name: #{name.inspect}\n"
+      inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
+      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
+      inspector << "└── value:\n"
+      inspector << inspector.child_node(value, "    ")
+      inspector.to_str
+    end
+
+    # Sometimes you want to check an instance of a node against a list of
+    # classes to see what kind of behavior to perform. Usually this is done by
+    # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+    # case statement and doing `case node; when cls1; when cls2; end`. Both of
+    # these approaches are relatively slow because of the constant lookups,
+    # method calls, and/or array allocations.
+    #
+    # Instead, you can call #type, which will return to you a symbol that you
+    # can use for comparison. This is faster than the other approaches because
+    # it uses a single integer comparison, but also because if you're on CRuby
+    # you can take advantage of the fact that case statements with all symbol
+    # keys will use a jump table.
+    #
+    # def type: () -> Symbol
+    def type
+      :instance_variable_and_write_node
+    end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :instance_variable_and_write_node
+    end
+  end
+
+  # Represents assigning to an instance variable using an operator that isn't `=`.
+  #
+  #     @target += value
+  #     ^^^^^^^^^^^^^^^^
+  class InstanceVariableOperatorWriteNode < Node
+    # attr_reader name: Symbol
+    attr_reader :name
 
     # attr_reader name_loc: Location
     attr_reader :name_loc
@@ -7343,6 +8493,16 @@ module Prism
     def type
       :instance_variable_operator_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :instance_variable_operator_write_node
+    end
   end
 
   # Represents the use of the `||=` operator for assignment to an instance variable.
@@ -7442,6 +8602,16 @@ module Prism
     def type
       :instance_variable_or_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :instance_variable_or_write_node
+    end
   end
 
   # Represents referencing an instance variable.
@@ -7517,6 +8687,16 @@ module Prism
     def type
       :instance_variable_read_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :instance_variable_read_node
+    end
   end
 
   # Represents writing to an instance variable in a context that doesn't have an explicit value.
@@ -7592,6 +8772,16 @@ module Prism
     def type
       :instance_variable_target_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :instance_variable_target_node
+    end
   end
 
   # Represents writing to an instance variable.
@@ -7691,6 +8881,16 @@ module Prism
     def type
       :instance_variable_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :instance_variable_write_node
+    end
   end
 
   # Represents an integer number literal.
@@ -7787,6 +8987,16 @@ module Prism
     def type
       :integer_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :integer_node
+    end
   end
 
   # Represents a regular expression literal that contains interpolation that
@@ -7886,6 +9096,11 @@ module Prism
       flags.anybits?(RegularExpressionFlags::MULTI_LINE)
     end
 
+    # def once?: () -> bool
+    def once?
+      flags.anybits?(RegularExpressionFlags::ONCE)
+    end
+
     # def euc_jp?: () -> bool
     def euc_jp?
       flags.anybits?(RegularExpressionFlags::EUC_JP)
@@ -7906,17 +9121,12 @@ module Prism
       flags.anybits?(RegularExpressionFlags::UTF_8)
     end
 
-    # def once?: () -> bool
-    def once?
-      flags.anybits?(RegularExpressionFlags::ONCE)
-    end
-
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
       inspector << "├── parts: #{inspector.list("#{inspector.prefix}│   ", parts)}"
       inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
-      flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?), ("once" if once?)].compact
+      flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("once" if once?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?)].compact
       inspector << "└── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector.to_str
     end
@@ -7938,6 +9148,16 @@ module Prism
     def type
       :interpolated_match_last_line_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :interpolated_match_last_line_node
+    end
   end
 
   # Represents a regular expression literal that contains interpolation.
@@ -8035,6 +9255,11 @@ module Prism
       flags.anybits?(RegularExpressionFlags::MULTI_LINE)
     end
 
+    # def once?: () -> bool
+    def once?
+      flags.anybits?(RegularExpressionFlags::ONCE)
+    end
+
     # def euc_jp?: () -> bool
     def euc_jp?
       flags.anybits?(RegularExpressionFlags::EUC_JP)
@@ -8055,17 +9280,12 @@ module Prism
       flags.anybits?(RegularExpressionFlags::UTF_8)
     end
 
-    # def once?: () -> bool
-    def once?
-      flags.anybits?(RegularExpressionFlags::ONCE)
-    end
-
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
       inspector << "├── parts: #{inspector.list("#{inspector.prefix}│   ", parts)}"
       inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
-      flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?), ("once" if once?)].compact
+      flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("once" if once?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?)].compact
       inspector << "└── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector.to_str
     end
@@ -8087,6 +9307,16 @@ module Prism
     def type
       :interpolated_regular_expression_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :interpolated_regular_expression_node
+    end
   end
 
   # Represents a string literal that contains interpolation.
@@ -8189,6 +9419,16 @@ module Prism
     def type
       :interpolated_string_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :interpolated_string_node
+    end
   end
 
   # Represents a symbol literal that contains interpolation.
@@ -8291,6 +9531,16 @@ module Prism
     def type
       :interpolated_symbol_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :interpolated_symbol_node
+    end
   end
 
   # Represents an xstring literal that contains interpolation.
@@ -8393,6 +9643,16 @@ module Prism
     def type
       :interpolated_x_string_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :interpolated_x_string_node
+    end
   end
 
   # Represents a hash literal without opening and closing braces.
@@ -8468,6 +9728,16 @@ module Prism
     def type
       :keyword_hash_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :keyword_hash_node
+    end
   end
 
   # Represents a keyword parameter to a method, block, or lambda definition.
@@ -8567,6 +9837,16 @@ module Prism
     def type
       :keyword_parameter_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :keyword_parameter_node
+    end
   end
 
   # Represents a keyword rest parameter to a method, block, or lambda definition.
@@ -8660,6 +9940,16 @@ module Prism
     def type
       :keyword_rest_parameter_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :keyword_rest_parameter_node
+    end
   end
 
   # Represents using a lambda literal (not the lambda method call).
@@ -8793,6 +10083,16 @@ module Prism
     def type
       :lambda_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :lambda_node
+    end
   end
 
   # Represents the use of the `&&=` operator for assignment to a local variable.
@@ -8898,6 +10198,16 @@ module Prism
     def type
       :local_variable_and_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :local_variable_and_write_node
+    end
   end
 
   # Represents assigning to a local variable using an operator that isn't `=`.
@@ -9004,6 +10314,16 @@ module Prism
     def type
       :local_variable_operator_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :local_variable_operator_write_node
+    end
   end
 
   # Represents the use of the `||=` operator for assignment to a local variable.
@@ -9109,6 +10429,16 @@ module Prism
     def type
       :local_variable_or_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :local_variable_or_write_node
+    end
   end
 
   # Represents reading a local variable. Note that this requires that a local
@@ -9192,6 +10522,16 @@ module Prism
     def type
       :local_variable_read_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :local_variable_read_node
+    end
   end
 
   # Represents writing to a local variable in a context that doesn't have an explicit value.
@@ -9273,6 +10613,16 @@ module Prism
     def type
       :local_variable_target_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :local_variable_target_node
+    end
   end
 
   # Represents writing to a local variable.
@@ -9378,6 +10728,16 @@ module Prism
     def type
       :local_variable_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :local_variable_write_node
+    end
   end
 
   # Represents a regular expression literal used in the predicate of a
@@ -9482,6 +10842,11 @@ module Prism
       flags.anybits?(RegularExpressionFlags::MULTI_LINE)
     end
 
+    # def once?: () -> bool
+    def once?
+      flags.anybits?(RegularExpressionFlags::ONCE)
+    end
+
     # def euc_jp?: () -> bool
     def euc_jp?
       flags.anybits?(RegularExpressionFlags::EUC_JP)
@@ -9502,18 +10867,13 @@ module Prism
       flags.anybits?(RegularExpressionFlags::UTF_8)
     end
 
-    # def once?: () -> bool
-    def once?
-      flags.anybits?(RegularExpressionFlags::ONCE)
-    end
-
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
       inspector << "├── content_loc: #{inspector.location(content_loc)}\n"
       inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
       inspector << "├── unescaped: #{unescaped.inspect}\n"
-      flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?), ("once" if once?)].compact
+      flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("once" if once?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?)].compact
       inspector << "└── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector.to_str
     end
@@ -9535,6 +10895,16 @@ module Prism
     def type
       :match_last_line_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :match_last_line_node
+    end
   end
 
   # Represents the use of the modifier `in` operator.
@@ -9629,6 +10999,16 @@ module Prism
     def type
       :match_predicate_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :match_predicate_node
+    end
   end
 
   # Represents the use of the `=>` operator.
@@ -9723,6 +11103,16 @@ module Prism
     def type
       :match_required_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :match_required_node
+    end
   end
 
   # Represents writing local variables using a regular expression match with
@@ -9806,6 +11196,16 @@ module Prism
     def type
       :match_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :match_write_node
+    end
   end
 
   # Represents a node that is missing from the source and results in a syntax
@@ -9873,6 +11273,16 @@ module Prism
     def type
       :missing_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :missing_node
+    end
   end
 
   # Represents a module declaration involving the `module` keyword.
@@ -9997,6 +11407,16 @@ module Prism
     def type
       :module_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :module_node
+    end
   end
 
   # Represents a multi-target expression.
@@ -10094,6 +11514,16 @@ module Prism
     def type
       :multi_target_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :multi_target_node
+    end
   end
 
   # Represents a write to a multi-target expression.
@@ -10209,6 +11639,16 @@ module Prism
     def type
       :multi_write_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :multi_write_node
+    end
   end
 
   # Represents the use of the `next` keyword.
@@ -10302,6 +11742,16 @@ module Prism
     def type
       :next_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :next_node
+    end
   end
 
   # Represents the use of the `nil` keyword.
@@ -10371,6 +11821,16 @@ module Prism
     def type
       :nil_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :nil_node
+    end
   end
 
   # Represents the use of `**nil` inside method arguments.
@@ -10463,6 +11923,16 @@ module Prism
     def type
       :no_keywords_parameter_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :no_keywords_parameter_node
+    end
   end
 
   # Represents reading a numbered reference to a capture in the previous match.
@@ -10538,6 +12008,16 @@ module Prism
     def type
       :numbered_reference_read_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :numbered_reference_read_node
+    end
   end
 
   # Represents an optional parameter to a method, block, or lambda definition.
@@ -10638,6 +12118,16 @@ module Prism
     def type
       :optional_parameter_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :optional_parameter_node
+    end
   end
 
   # Represents the use of the `||` operator or the `or` keyword.
@@ -10732,6 +12222,16 @@ module Prism
     def type
       :or_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :or_node
+    end
   end
 
   # Represents the list of parameters on a method, block, or lambda definition.
@@ -10867,6 +12367,16 @@ module Prism
     def type
       :parameters_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :parameters_node
+    end
   end
 
   # Represents a parenthesized expression
@@ -10975,6 +12485,16 @@ module Prism
     def type
       :parentheses_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :parentheses_node
+    end
   end
 
   # Represents the use of the `^` operator for pinning an expression in a
@@ -11085,6 +12605,16 @@ module Prism
     def type
       :pinned_expression_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :pinned_expression_node
+    end
   end
 
   # Represents the use of the `^` operator for pinning a variable in a pattern
@@ -11173,6 +12703,16 @@ module Prism
     def type
       :pinned_variable_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :pinned_variable_node
+    end
   end
 
   # Represents the use of the `END` keyword.
@@ -11288,6 +12828,16 @@ module Prism
     def type
       :post_execution_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :post_execution_node
+    end
   end
 
   # Represents the use of the `BEGIN` keyword.
@@ -11403,6 +12953,16 @@ module Prism
     def type
       :pre_execution_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :pre_execution_node
+    end
   end
 
   # The top level node of any parse tree.
@@ -11482,6 +13042,16 @@ module Prism
     def type
       :program_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :program_node
+    end
   end
 
   # Represents the use of the `..` or `...` operators.
@@ -11602,6 +13172,16 @@ module Prism
     def type
       :range_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :range_node
+    end
   end
 
   # Represents a rational number literal.
@@ -11678,6 +13258,16 @@ module Prism
     def type
       :rational_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :rational_node
+    end
   end
 
   # Represents the use of the `redo` keyword.
@@ -11747,6 +13337,16 @@ module Prism
     def type
       :redo_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :redo_node
+    end
   end
 
   # Represents a regular expression literal with no interpolation.
@@ -11849,6 +13449,11 @@ module Prism
       flags.anybits?(RegularExpressionFlags::MULTI_LINE)
     end
 
+    # def once?: () -> bool
+    def once?
+      flags.anybits?(RegularExpressionFlags::ONCE)
+    end
+
     # def euc_jp?: () -> bool
     def euc_jp?
       flags.anybits?(RegularExpressionFlags::EUC_JP)
@@ -11869,18 +13474,13 @@ module Prism
       flags.anybits?(RegularExpressionFlags::UTF_8)
     end
 
-    # def once?: () -> bool
-    def once?
-      flags.anybits?(RegularExpressionFlags::ONCE)
-    end
-
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
       inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
       inspector << "├── content_loc: #{inspector.location(content_loc)}\n"
       inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
       inspector << "├── unescaped: #{unescaped.inspect}\n"
-      flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?), ("once" if once?)].compact
+      flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("once" if once?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?)].compact
       inspector << "└── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector.to_str
     end
@@ -11902,6 +13502,16 @@ module Prism
     def type
       :regular_expression_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :regular_expression_node
+    end
   end
 
   # Represents a destructured required parameter node.
@@ -12000,6 +13610,16 @@ module Prism
     def type
       :required_destructured_parameter_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :required_destructured_parameter_node
+    end
   end
 
   # Represents a required parameter to a method, block, or lambda definition.
@@ -12076,6 +13696,16 @@ module Prism
     def type
       :required_parameter_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :required_parameter_node
+    end
   end
 
   # Represents an expression modified with a rescue.
@@ -12174,6 +13804,16 @@ module Prism
     def type
       :rescue_modifier_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :rescue_modifier_node
+    end
   end
 
   # Represents a rescue statement.
@@ -12315,6 +13955,16 @@ module Prism
     def type
       :rescue_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :rescue_node
+    end
   end
 
   # Represents a rest parameter to a method, block, or lambda definition.
@@ -12408,6 +14058,16 @@ module Prism
     def type
       :rest_parameter_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :rest_parameter_node
+    end
   end
 
   # Represents the use of the `retry` keyword.
@@ -12477,6 +14137,16 @@ module Prism
     def type
       :retry_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :retry_node
+    end
   end
 
   # Represents the use of the `return` keyword.
@@ -12570,6 +14240,16 @@ module Prism
     def type
       :return_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :return_node
+    end
   end
 
   # Represents the `self` keyword.
@@ -12639,6 +14319,16 @@ module Prism
     def type
       :self_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :self_node
+    end
   end
 
   # Represents a singleton class declaration involving the `class` keyword.
@@ -12768,6 +14458,16 @@ module Prism
     def type
       :singleton_class_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :singleton_class_node
+    end
   end
 
   # Represents the use of the `__ENCODING__` keyword.
@@ -12837,6 +14537,16 @@ module Prism
     def type
       :source_encoding_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :source_encoding_node
+    end
   end
 
   # Represents the use of the `__FILE__` keyword.
@@ -12912,6 +14622,16 @@ module Prism
     def type
       :source_file_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :source_file_node
+    end
   end
 
   # Represents the use of the `__LINE__` keyword.
@@ -12981,6 +14701,16 @@ module Prism
     def type
       :source_line_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :source_line_node
+    end
   end
 
   # Represents the use of the splat operator.
@@ -13074,6 +14804,16 @@ module Prism
     def type
       :splat_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :splat_node
+    end
   end
 
   # Represents a set of statements contained within some scope.
@@ -13149,6 +14889,16 @@ module Prism
     def type
       :statements_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :statements_node
+    end
   end
 
   # Represents the use of compile-time string concatenation.
@@ -13232,6 +14982,16 @@ module Prism
     def type
       :string_concat_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :string_concat_node
+    end
   end
 
   # Represents a string literal, a string contained within a `%w` list, or
@@ -13359,6 +15119,16 @@ module Prism
     def type
       :string_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :string_node
+    end
   end
 
   # Represents the use of the `super` keyword with parentheses or arguments.
@@ -13489,6 +15259,16 @@ module Prism
     def type
       :super_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :super_node
+    end
   end
 
   # Represents a symbol literal or a symbol contained within a `%i` list.
@@ -13600,6 +15380,16 @@ module Prism
     def type
       :symbol_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :symbol_node
+    end
   end
 
   # Represents the use of the literal `true` keyword.
@@ -13669,6 +15459,16 @@ module Prism
     def type
       :true_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :true_node
+    end
   end
 
   # Represents the use of the `undef` keyword.
@@ -13755,6 +15555,16 @@ module Prism
     def type
       :undef_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :undef_node
+    end
   end
 
   # Represents the use of the `unless` keyword, either in the block form or the modifier form.
@@ -13886,6 +15696,16 @@ module Prism
     def type
       :unless_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :unless_node
+    end
   end
 
   # Represents the use of the `until` keyword, either in the block form or the modifier form.
@@ -14017,6 +15837,16 @@ module Prism
     def type
       :until_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :until_node
+    end
   end
 
   # Represents the use of the `when` keyword within a case statement.
@@ -14119,6 +15949,16 @@ module Prism
     def type
       :when_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :when_node
+    end
   end
 
   # Represents the use of the `while` keyword, either in the block form or the modifier form.
@@ -14250,6 +16090,16 @@ module Prism
     def type
       :while_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :while_node
+    end
   end
 
   # Represents an xstring literal with no interpolation.
@@ -14358,6 +16208,16 @@ module Prism
     def type
       :x_string_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :x_string_node
+    end
   end
 
   # Represents the use of the `yield` keyword.
@@ -14473,6 +16333,16 @@ module Prism
     def type
       :yield_node
     end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :yield_node
+    end
   end
 
   module CallNodeFlags
@@ -14517,24 +16387,24 @@ module Prism
     # m - allows $ to match the end of lines within strings
     MULTI_LINE = 1 << 2
 
+    # o - only interpolates values into the regular expression once
+    ONCE = 1 << 3
+
     # e - forces the EUC-JP encoding
-    EUC_JP = 1 << 3
+    EUC_JP = 1 << 4
 
     # n - forces the ASCII-8BIT encoding
-    ASCII_8BIT = 1 << 4
+    ASCII_8BIT = 1 << 5
 
     # s - forces the Windows-31J encoding
-    WINDOWS_31J = 1 << 5
+    WINDOWS_31J = 1 << 6
 
     # u - forces the UTF-8 encoding
-    UTF_8 = 1 << 6
-
-    # o - only interpolates values into the regular expression once
-    ONCE = 1 << 7
+    UTF_8 = 1 << 7
   end
 
   module StringFlags
-    # frozen by virtue of a frozen_string_literal comment
+    # frozen by virtue of a `frozen_string_literal` comment
     FROZEN = 1 << 0
   end
 end