prism 0.13.0 → 0.14.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.
@@ -990,6 +1080,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 +1236,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 +1339,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 +1424,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 +1556,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 +1659,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 +1784,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 +1887,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.
@@ -1755,10 +1925,10 @@ module Prism
     # 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,7 +1937,7 @@ 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: Node?, call_operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_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, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location)
       @receiver = receiver
       @call_operator_loc = call_operator_loc
@@ -1913,6 +2083,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 +2139,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 +2281,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.
@@ -2129,10 +2319,10 @@ module Prism
     # 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,7 +2334,7 @@ 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: Node?, call_operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_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, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator, operator_loc, value, location)
       @receiver = receiver
       @call_operator_loc = call_operator_loc
@@ -2288,6 +2478,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.
@@ -2316,10 +2516,10 @@ module Prism
     # 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,7 +2528,7 @@ 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: Node?, call_operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_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, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location)
       @receiver = receiver
       @call_operator_loc = call_operator_loc
@@ -2474,6 +2674,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 +2778,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 +2913,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 +3070,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 +3179,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 +3289,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 +3398,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 +3483,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 +3568,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 +3677,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 +3786,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 +3896,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 +4005,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 +4109,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 +4220,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,6 +4325,16 @@ module Prism
     def type
       :constant_path_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_path_operator_write_node
+    end
   end
 
   # Represents the use of the `||=` operator for assignment to a constant path.
@@ -4069,6 +4429,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 +4540,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 +4650,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 +4735,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 +4820,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 +4929,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 +5130,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 +5249,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 +5363,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 +5477,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 +5574,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 +5692,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 +5771,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 +5914,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 +6041,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 +6120,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 +6272,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 +6353,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 +6433,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 +6525,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 +6634,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 +6744,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 +6853,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 +6938,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 +7023,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 +7132,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 +7239,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,10 +7375,20 @@ module Prism
     def type
       :hash_pattern_node
     end
-  end
 
-  # Represents the use of the `if` keyword, either in the block form or the modifier form.
-  #
+    # 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.
+  #
   #     bar if foo
   #     ^^^^^^^^^^
   #
@@ -6876,6 +7516,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 +7602,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 +7692,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,6 +7814,16 @@ 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.
@@ -7243,6 +7923,16 @@ module Prism
     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 `=`.
@@ -7343,6 +8033,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 +8142,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 +8227,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 +8312,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 +8421,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 +8527,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 +8636,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 +8661,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 +8688,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 +8795,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 +8820,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 +8847,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 +8959,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 +9071,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 +9183,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 +9268,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 +9377,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 +9480,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 +9623,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 +9738,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 +9854,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 +9969,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 +10062,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 +10153,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 +10268,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 +10382,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 +10407,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 +10435,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 +10539,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 +10643,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 +10736,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 +10813,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 +10947,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 +11054,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 +11179,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 +11282,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 +11361,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 +11463,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 +11548,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 +11658,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 +11762,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 +11907,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 +12025,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 +12145,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 +12243,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 +12368,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 +12493,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 +12582,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 +12712,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 +12798,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 +12877,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 +12989,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 +13014,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 +13042,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 +13150,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 +13236,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 +13344,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 +13495,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 +13598,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 +13677,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 +13780,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 +13859,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 +13998,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 +14077,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 +14162,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 +14241,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 +14344,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 +14429,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 +14522,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 +14659,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 +14799,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 +14920,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 +14999,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 +15095,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 +15236,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 +15377,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 +15489,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 +15630,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 +15748,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 +15873,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 +15927,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