prism 0.26.0 → 0.27.0

data/lib/prism/node.rb

@@ -176,20 +176,28 @@ module Prism
       { new_name: new_name, old_name: old_name, keyword_loc: keyword_loc, location: location }
     end
 
-    # attr_reader new_name: Prism::node
+    # Represents the new name of the global variable that can be used after aliasing. This can be either a global variable, a back reference, or a numbered reference.
+    #
+    #     alias $foo $bar
+    #           ^^^^
     attr_reader :new_name
 
-    # attr_reader old_name: Prism::node
+    # Represents the old name of the global variable that could be used before aliasing. This can be either a global variable, a back reference, or a numbered reference.
+    #
+    #     alias $foo $bar
+    #                ^^^^
     attr_reader :old_name
 
-    # attr_reader keyword_loc: Location
+    # The location of the `alias` keyword.
+    #
+    #     alias $foo $bar
+    #     ^^^^^
     def keyword_loc
       location = @keyword_loc
       return location if location.is_a?(Location)
       @keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def keyword: () -> String
     def keyword
       keyword_loc.slice
@@ -233,6 +241,15 @@ module Prism
     def self.type
       :alias_global_variable_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(AliasGlobalVariableNode) &&
+        (new_name === other.new_name) &&
+        (old_name === other.old_name) &&
+        (keyword_loc.nil? == other.keyword_loc.nil?)
+    end
   end
 
   # Represents the use of the `alias` keyword to alias a method.
@@ -296,7 +313,6 @@ module Prism
       @keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def keyword: () -> String
     def keyword
       keyword_loc.slice
@@ -340,6 +356,15 @@ module Prism
     def self.type
       :alias_method_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(AliasMethodNode) &&
+        (new_name === other.new_name) &&
+        (old_name === other.old_name) &&
+        (keyword_loc.nil? == other.keyword_loc.nil?)
+    end
   end
 
   # Represents an alternation pattern in pattern matching.
@@ -403,7 +428,6 @@ module Prism
       @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -447,6 +471,15 @@ module Prism
     def self.type
       :alternation_pattern_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(AlternationPatternNode) &&
+        (left === other.left) &&
+        (right === other.right) &&
+        (operator_loc.nil? == other.operator_loc.nil?)
+    end
   end
 
   # Represents the use of the `&&` operator or the `and` keyword.
@@ -525,7 +558,6 @@ module Prism
       @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -569,6 +601,15 @@ module Prism
     def self.type
       :and_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(AndNode) &&
+        (left === other.left) &&
+        (right === other.right) &&
+        (operator_loc.nil? == other.operator_loc.nil?)
+    end
   end
 
   # Represents a set of arguments to a method or a keyword.
@@ -618,14 +659,13 @@ module Prism
       { flags: flags, arguments: arguments, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader arguments: Array[Prism::node]
     attr_reader :arguments
 
-
     # def contains_keyword_splat?: () -> bool
     def contains_keyword_splat?
       flags.anybits?(ArgumentsNodeFlags::CONTAINS_KEYWORD_SPLAT)
@@ -667,6 +707,15 @@ module Prism
     def self.type
       :arguments_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ArgumentsNode) &&
+        (flags === other.flags) &&
+        (arguments.length == other.arguments.length) &&
+        arguments.zip(other.arguments).all? { |left, right| left === right }
+    end
   end
 
   # Represents an array literal. This can be a regular array using brackets or a special array using % like %w or %i.
@@ -718,14 +767,19 @@ module Prism
       { flags: flags, elements: elements, opening_loc: opening_loc, closing_loc: closing_loc, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
-    # attr_reader elements: Array[Prism::node]
+    # Represent the list of zero or more [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression) within the array.
     attr_reader :elements
 
-    # attr_reader opening_loc: Location?
+    # Represents the optional source location for the opening token.
+    #
+    #     [1,2,3]                 # "["
+    #     %w[foo bar baz]         # "%w["
+    #     %I(apple orange banana) # "%I("
+    #     foo = 1, 2, 3           # nil
     def opening_loc
       location = @opening_loc
       case location
@@ -738,7 +792,12 @@ module Prism
       end
     end
 
-    # attr_reader closing_loc: Location?
+    # Represents the optional source location for the closing token.
+    #
+    #     [1,2,3]                 # "]"
+    #     %w[foo bar baz]         # "]"
+    #     %I(apple orange banana) # ")"
+    #     foo = 1, 2, 3           # nil
     def closing_loc
       location = @closing_loc
       case location
@@ -751,7 +810,6 @@ module Prism
       end
     end
 
-
     # def contains_splat?: () -> bool
     def contains_splat?
       flags.anybits?(ArrayNodeFlags::CONTAINS_SPLAT)
@@ -805,6 +863,17 @@ module Prism
     def self.type
       :array_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ArrayNode) &&
+        (flags === other.flags) &&
+        (elements.length == other.elements.length) &&
+        elements.zip(other.elements).all? { |left, right| left === right } &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (closing_loc.nil? == other.closing_loc.nil?)
+    end
   end
 
   # Represents an array pattern in pattern matching.
@@ -913,7 +982,6 @@ module Prism
       end
     end
 
-
     # def opening: () -> String?
     def opening
       opening_loc&.slice
@@ -973,6 +1041,20 @@ module Prism
     def self.type
       :array_pattern_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ArrayPatternNode) &&
+        (constant === other.constant) &&
+        (requireds.length == other.requireds.length) &&
+        requireds.zip(other.requireds).all? { |left, right| left === right } &&
+        (rest === other.rest) &&
+        (posts.length == other.posts.length) &&
+        posts.zip(other.posts).all? { |left, right| left === right } &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (closing_loc.nil? == other.closing_loc.nil?)
+    end
   end
 
   # Represents a hash key/value pair.
@@ -1060,7 +1142,6 @@ module Prism
       end
     end
 
-
     # def operator: () -> String?
     def operator
       operator_loc&.slice
@@ -1104,6 +1185,15 @@ module Prism
     def self.type
       :assoc_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(AssocNode) &&
+        (key === other.key) &&
+        (value === other.value) &&
+        (operator_loc.nil? == other.operator_loc.nil?)
+    end
   end
 
   # Represents a splat in a hash literal.
@@ -1171,7 +1261,6 @@ module Prism
       @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -1217,6 +1306,14 @@ module Prism
     def self.type
       :assoc_splat_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(AssocSplatNode) &&
+        (value === other.value) &&
+        (operator_loc.nil? == other.operator_loc.nil?)
+    end
   end
 
   # Represents reading a reference to a field in the previous match.
@@ -1272,7 +1369,6 @@ module Prism
     #     $+ # name `:$+`
     attr_reader :name
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -1307,6 +1403,13 @@ module Prism
     def self.type
       :back_reference_read_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(BackReferenceReadNode) &&
+        (name === other.name)
+    end
   end
 
   # Represents a begin statement.
@@ -1409,7 +1512,6 @@ module Prism
       end
     end
 
-
     # def begin_keyword: () -> String?
     def begin_keyword
       begin_keyword_loc&.slice
@@ -1479,6 +1581,18 @@ module Prism
     def self.type
       :begin_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(BeginNode) &&
+        (begin_keyword_loc.nil? == other.begin_keyword_loc.nil?) &&
+        (statements === other.statements) &&
+        (rescue_clause === other.rescue_clause) &&
+        (else_clause === other.else_clause) &&
+        (ensure_clause === other.ensure_clause) &&
+        (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
+    end
   end
 
   # Represents block method arguments.
@@ -1540,7 +1654,6 @@ module Prism
       @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -1586,6 +1699,14 @@ module Prism
     def self.type
       :block_argument_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(BlockArgumentNode) &&
+        (expression === other.expression) &&
+        (operator_loc.nil? == other.operator_loc.nil?)
+    end
   end
 
   # Represents a block local variable.
@@ -1635,14 +1756,13 @@ module Prism
       { flags: flags, name: name, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader name: Symbol
     attr_reader :name
 
-
     # def repeated_parameter?: () -> bool
     def repeated_parameter?
       flags.anybits?(ParameterFlags::REPEATED_PARAMETER)
@@ -1684,6 +1804,14 @@ module Prism
     def self.type
       :block_local_variable_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(BlockLocalVariableNode) &&
+        (flags === other.flags) &&
+        (name === other.name)
+    end
   end
 
   # Represents a block of ruby code.
@@ -1762,7 +1890,6 @@ module Prism
       @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def opening: () -> String
     def opening
       opening_loc.slice
@@ -1821,6 +1948,18 @@ module Prism
     def self.type
       :block_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(BlockNode) &&
+        (locals.length == other.locals.length) &&
+        locals.zip(other.locals).all? { |left, right| left === right } &&
+        (parameters === other.parameters) &&
+        (body === other.body) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (closing_loc.nil? == other.closing_loc.nil?)
+    end
   end
 
   # Represents a block parameter to a method, block, or lambda definition.
@@ -1873,9 +2012,9 @@ module Prism
       { flags: flags, name: name, name_loc: name_loc, operator_loc: operator_loc, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader name: Symbol?
     attr_reader :name
@@ -1900,7 +2039,6 @@ module Prism
       @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def repeated_parameter?: () -> bool
     def repeated_parameter?
       flags.anybits?(ParameterFlags::REPEATED_PARAMETER)
@@ -1953,6 +2091,16 @@ module Prism
     def self.type
       :block_parameter_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(BlockParameterNode) &&
+        (flags === other.flags) &&
+        (name === other.name) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (operator_loc.nil? == other.operator_loc.nil?)
+    end
   end
 
   # Represents a block's parameters declaration.
@@ -2043,7 +2191,6 @@ module Prism
       end
     end
 
-
     # def opening: () -> String?
     def opening
       opening_loc&.slice
@@ -2096,6 +2243,17 @@ module Prism
     def self.type
       :block_parameters_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(BlockParametersNode) &&
+        (parameters === other.parameters) &&
+        (locals.length == other.locals.length) &&
+        locals.zip(other.locals).all? { |left, right| left === right } &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (closing_loc.nil? == other.closing_loc.nil?)
+    end
   end
 
   # Represents the use of the `break` keyword.
@@ -2147,17 +2305,22 @@ module Prism
       { arguments: arguments, keyword_loc: keyword_loc, location: location }
     end
 
-    # attr_reader arguments: ArgumentsNode?
+    # The arguments to the break statement, if present. These can be any [non-void expressions](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+    #
+    #     break foo
+    #           ^^^
     attr_reader :arguments
 
-    # attr_reader keyword_loc: Location
+    # The location of the `break` keyword.
+    #
+    #     break foo
+    #     ^^^^^
     def keyword_loc
       location = @keyword_loc
       return location if location.is_a?(Location)
       @keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def keyword: () -> String
     def keyword
       keyword_loc.slice
@@ -2203,6 +2366,14 @@ module Prism
     def self.type
       :break_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(BreakNode) &&
+        (arguments === other.arguments) &&
+        (keyword_loc.nil? == other.keyword_loc.nil?)
+    end
   end
 
   # Represents the use of the `&&=` operator on a call.
@@ -2261,9 +2432,9 @@ module Prism
       { flags: flags, receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, read_name: read_name, write_name: write_name, operator_loc: operator_loc, value: value, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader receiver: Prism::node?
     attr_reader :receiver
@@ -2310,7 +2481,6 @@ module Prism
     # attr_reader value: Prism::node
     attr_reader :value
 
-
     # def safe_navigation?: () -> bool
     def safe_navigation?
       flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -2394,6 +2564,20 @@ module Prism
     def self.type
       :call_and_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(CallAndWriteNode) &&
+        (flags === other.flags) &&
+        (receiver === other.receiver) &&
+        (call_operator_loc.nil? == other.call_operator_loc.nil?) &&
+        (message_loc.nil? == other.message_loc.nil?) &&
+        (read_name === other.read_name) &&
+        (write_name === other.write_name) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value)
+    end
   end
 
   # Represents a method call, in all of the various forms that can take.
@@ -2469,9 +2653,9 @@ module Prism
       { flags: flags, receiver: receiver, call_operator_loc: call_operator_loc, name: name, message_loc: message_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # The object that the method is being called on. This can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
@@ -2546,7 +2730,6 @@ module Prism
     # attr_reader block: Prism::node?
     attr_reader :block
 
-
     # def safe_navigation?: () -> bool
     def safe_navigation?
       flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -2645,6 +2828,21 @@ module Prism
     def self.type
       :call_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(CallNode) &&
+        (flags === other.flags) &&
+        (receiver === other.receiver) &&
+        (call_operator_loc.nil? == other.call_operator_loc.nil?) &&
+        (name === other.name) &&
+        (message_loc.nil? == other.message_loc.nil?) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (arguments === other.arguments) &&
+        (closing_loc.nil? == other.closing_loc.nil?) &&
+        (block === other.block)
+    end
   end
 
   # Represents the use of an assignment operator on a call.
@@ -2704,9 +2902,9 @@ module Prism
       { flags: flags, receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, read_name: read_name, write_name: write_name, operator: operator, operator_loc: operator_loc, value: value, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader receiver: Prism::node?
     attr_reader :receiver
@@ -2756,7 +2954,6 @@ module Prism
     # attr_reader value: Prism::node
     attr_reader :value
 
-
     # def safe_navigation?: () -> bool
     def safe_navigation?
       flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -2836,6 +3033,21 @@ module Prism
     def self.type
       :call_operator_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(CallOperatorWriteNode) &&
+        (flags === other.flags) &&
+        (receiver === other.receiver) &&
+        (call_operator_loc.nil? == other.call_operator_loc.nil?) &&
+        (message_loc.nil? == other.message_loc.nil?) &&
+        (read_name === other.read_name) &&
+        (write_name === other.write_name) &&
+        (operator === other.operator) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value)
+    end
   end
 
   # Represents the use of the `||=` operator on a call.
@@ -2894,9 +3106,9 @@ module Prism
       { flags: flags, receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, read_name: read_name, write_name: write_name, operator_loc: operator_loc, value: value, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader receiver: Prism::node?
     attr_reader :receiver
@@ -2943,7 +3155,6 @@ module Prism
     # attr_reader value: Prism::node
     attr_reader :value
 
-
     # def safe_navigation?: () -> bool
     def safe_navigation?
       flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -3027,6 +3238,20 @@ module Prism
     def self.type
       :call_or_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(CallOrWriteNode) &&
+        (flags === other.flags) &&
+        (receiver === other.receiver) &&
+        (call_operator_loc.nil? == other.call_operator_loc.nil?) &&
+        (message_loc.nil? == other.message_loc.nil?) &&
+        (read_name === other.read_name) &&
+        (write_name === other.write_name) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value)
+    end
   end
 
   # Represents assigning to a method call.
@@ -3087,9 +3312,9 @@ module Prism
       { flags: flags, receiver: receiver, call_operator_loc: call_operator_loc, name: name, message_loc: message_loc, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader receiver: Prism::node
     attr_reader :receiver
@@ -3111,7 +3336,6 @@ module Prism
       @message_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def safe_navigation?: () -> bool
     def safe_navigation?
       flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -3182,6 +3406,17 @@ module Prism
     def self.type
       :call_target_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(CallTargetNode) &&
+        (flags === other.flags) &&
+        (receiver === other.receiver) &&
+        (call_operator_loc.nil? == other.call_operator_loc.nil?) &&
+        (name === other.name) &&
+        (message_loc.nil? == other.message_loc.nil?)
+    end
   end
 
   # Represents assigning to a local variable in pattern matching.
@@ -3245,7 +3480,6 @@ module Prism
       @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -3289,6 +3523,15 @@ module Prism
     def self.type
       :capture_pattern_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(CapturePatternNode) &&
+        (value === other.value) &&
+        (target === other.target) &&
+        (operator_loc.nil? == other.operator_loc.nil?)
+    end
   end
 
   # Represents the use of a case statement for pattern matching.
@@ -3370,7 +3613,6 @@ module Prism
       @end_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def case_keyword: () -> String
     def case_keyword
       case_keyword_loc.slice
@@ -3429,6 +3671,18 @@ module Prism
     def self.type
       :case_match_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(CaseMatchNode) &&
+        (predicate === other.predicate) &&
+        (conditions.length == other.conditions.length) &&
+        conditions.zip(other.conditions).all? { |left, right| left === right } &&
+        (consequent === other.consequent) &&
+        (case_keyword_loc.nil? == other.case_keyword_loc.nil?) &&
+        (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
+    end
   end
 
   # Represents the use of a case statement.
@@ -3510,7 +3764,6 @@ module Prism
       @end_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def case_keyword: () -> String
     def case_keyword
       case_keyword_loc.slice
@@ -3569,6 +3822,18 @@ module Prism
     def self.type
       :case_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(CaseNode) &&
+        (predicate === other.predicate) &&
+        (conditions.length == other.conditions.length) &&
+        conditions.zip(other.conditions).all? { |left, right| left === right } &&
+        (consequent === other.consequent) &&
+        (case_keyword_loc.nil? == other.case_keyword_loc.nil?) &&
+        (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
+    end
   end
 
   # Represents a class declaration involving the `class` keyword.
@@ -3670,7 +3935,6 @@ module Prism
     # attr_reader name: Symbol
     attr_reader :name
 
-
     # def class_keyword: () -> String
     def class_keyword
       class_keyword_loc.slice
@@ -3738,6 +4002,21 @@ module Prism
     def self.type
       :class_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ClassNode) &&
+        (locals.length == other.locals.length) &&
+        locals.zip(other.locals).all? { |left, right| left === right } &&
+        (class_keyword_loc.nil? == other.class_keyword_loc.nil?) &&
+        (constant_path === other.constant_path) &&
+        (inheritance_operator_loc.nil? == other.inheritance_operator_loc.nil?) &&
+        (superclass === other.superclass) &&
+        (body === other.body) &&
+        (end_keyword_loc.nil? == other.end_keyword_loc.nil?) &&
+        (name === other.name)
+    end
   end
 
   # Represents the use of the `&&=` operator for assignment to a class variable.
@@ -3809,7 +4088,6 @@ module Prism
     # attr_reader value: Prism::node
     attr_reader :value
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -3853,6 +4131,16 @@ module Prism
     def self.type
       :class_variable_and_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ClassVariableAndWriteNode) &&
+        (name === other.name) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value)
+    end
   end
 
   # Represents assigning to a class variable using an operator that isn't `=`.
@@ -3928,7 +4216,6 @@ module Prism
     # attr_reader operator: Symbol
     attr_reader :operator
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -3968,6 +4255,17 @@ module Prism
     def self.type
       :class_variable_operator_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ClassVariableOperatorWriteNode) &&
+        (name === other.name) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value) &&
+        (operator === other.operator)
+    end
   end
 
   # Represents the use of the `||=` operator for assignment to a class variable.
@@ -4039,7 +4337,6 @@ module Prism
     # attr_reader value: Prism::node
     attr_reader :value
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -4083,6 +4380,16 @@ module Prism
     def self.type
       :class_variable_or_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ClassVariableOrWriteNode) &&
+        (name === other.name) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value)
+    end
   end
 
   # Represents referencing a class variable.
@@ -4138,7 +4445,6 @@ module Prism
     #     @@_test # name `:@@_test`
     attr_reader :name
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -4173,6 +4479,13 @@ module Prism
     def self.type
       :class_variable_read_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ClassVariableReadNode) &&
+        (name === other.name)
+    end
   end
 
   # Represents writing to a class variable in a context that doesn't have an explicit value.
@@ -4224,7 +4537,6 @@ module Prism
     # attr_reader name: Symbol
     attr_reader :name
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -4259,6 +4571,13 @@ module Prism
     def self.type
       :class_variable_target_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ClassVariableTargetNode) &&
+        (name === other.name)
+    end
   end
 
   # Represents writing to a class variable.
@@ -4327,8 +4646,7 @@ module Prism
       @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-    # The value to assign to the class variable. Can be any node that
-    # represents a non-void expression.
+    # The value to write to the class variable. This can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
     #     @@foo = :bar
     #             ^^^^
@@ -4347,7 +4665,6 @@ module Prism
       @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -4391,6 +4708,16 @@ module Prism
     def self.type
       :class_variable_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ClassVariableWriteNode) &&
+        (name === other.name) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (value === other.value) &&
+        (operator_loc.nil? == other.operator_loc.nil?)
+    end
   end
 
   # Represents the use of the `&&=` operator for assignment to a constant.
@@ -4462,7 +4789,6 @@ module Prism
     # attr_reader value: Prism::node
     attr_reader :value
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -4506,6 +4832,16 @@ module Prism
     def self.type
       :constant_and_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ConstantAndWriteNode) &&
+        (name === other.name) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value)
+    end
   end
 
   # Represents assigning to a constant using an operator that isn't `=`.
@@ -4581,7 +4917,6 @@ module Prism
     # attr_reader operator: Symbol
     attr_reader :operator
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -4621,6 +4956,17 @@ module Prism
     def self.type
       :constant_operator_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ConstantOperatorWriteNode) &&
+        (name === other.name) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value) &&
+        (operator === other.operator)
+    end
   end
 
   # Represents the use of the `||=` operator for assignment to a constant.
@@ -4692,7 +5038,6 @@ module Prism
     # attr_reader value: Prism::node
     attr_reader :value
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -4736,6 +5081,16 @@ module Prism
     def self.type
       :constant_or_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ConstantOrWriteNode) &&
+        (name === other.name) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value)
+    end
   end
 
   # Represents the use of the `&&=` operator for assignment to a constant path.
@@ -4799,7 +5154,6 @@ module Prism
     # attr_reader value: Prism::node
     attr_reader :value
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -4843,6 +5197,15 @@ module Prism
     def self.type
       :constant_path_and_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ConstantPathAndWriteNode) &&
+        (target === other.target) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value)
+    end
   end
 
   # Represents accessing a constant through a path of `::` operators.
@@ -4896,20 +5259,44 @@ module Prism
       { parent: parent, child: child, delimiter_loc: delimiter_loc, location: location }
     end
 
-    # attr_reader parent: Prism::node?
+    # The left-hand node of the path, if present. It can be `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression). It will be `nil` when the constant lookup is at the root of the module tree.
+    #
+    #     Foo::Bar
+    #     ^^^
+    #
+    #     self::Test
+    #     ^^^^
+    #
+    #     a.b::C
+    #     ^^^
     attr_reader :parent
 
-    # attr_reader child: ConstantReadNode | MissingNode
+    # The right-hand node of the path. Always a `ConstantReadNode` in a
+    # valid Ruby syntax tree.
+    #
+    #     ::Foo
+    #       ^^^
+    #
+    #     self::Test
+    #           ^^^^
+    #
+    #     a.b::C
+    #          ^
     attr_reader :child
 
-    # attr_reader delimiter_loc: Location
+    # The location of the `::` delimiter.
+    #
+    #     ::Foo
+    #     ^^
+    #
+    #     One::Two
+    #        ^^
     def delimiter_loc
       location = @delimiter_loc
       return location if location.is_a?(Location)
       @delimiter_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def delimiter: () -> String
     def delimiter
       delimiter_loc.slice
@@ -4957,6 +5344,15 @@ module Prism
     def self.type
       :constant_path_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ConstantPathNode) &&
+        (parent === other.parent) &&
+        (child === other.child) &&
+        (delimiter_loc.nil? == other.delimiter_loc.nil?)
+    end
   end
 
   # Represents assigning to a constant path using an operator that isn't `=`.
@@ -5024,7 +5420,6 @@ module Prism
     # attr_reader operator: Symbol
     attr_reader :operator
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -5064,6 +5459,16 @@ module Prism
     def self.type
       :constant_path_operator_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ConstantPathOperatorWriteNode) &&
+        (target === other.target) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value) &&
+        (operator === other.operator)
+    end
   end
 
   # Represents the use of the `||=` operator for assignment to a constant path.
@@ -5127,7 +5532,6 @@ module Prism
     # attr_reader value: Prism::node
     attr_reader :value
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -5171,6 +5575,15 @@ module Prism
     def self.type
       :constant_path_or_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ConstantPathOrWriteNode) &&
+        (target === other.target) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value)
+    end
   end
 
   # Represents writing to a constant path in a context that doesn't have an explicit value.
@@ -5237,7 +5650,6 @@ module Prism
       @delimiter_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def delimiter: () -> String
     def delimiter
       delimiter_loc.slice
@@ -5285,6 +5697,15 @@ module Prism
     def self.type
       :constant_path_target_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ConstantPathTargetNode) &&
+        (parent === other.parent) &&
+        (child === other.child) &&
+        (delimiter_loc.nil? == other.delimiter_loc.nil?)
+    end
   end
 
   # Represents writing to a constant path.
@@ -5341,20 +5762,31 @@ module Prism
       { target: target, operator_loc: operator_loc, value: value, location: location }
     end
 
-    # attr_reader target: ConstantPathNode
+    # A node representing the constant path being written to.
+    #
+    #     Foo::Bar = 1
+    #     ^^^^^^^^
+    #
+    #     ::Foo = :abc
+    #     ^^^^^
     attr_reader :target
 
-    # attr_reader operator_loc: Location
+    # The location of the `=` operator.
+    #
+    #     ::ABC = 123
+    #           ^
     def operator_loc
       location = @operator_loc
       return location if location.is_a?(Location)
       @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-    # attr_reader value: Prism::node
+    # The value to write to the constant path. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+    #
+    #     FOO::BAR = :abc
+    #                ^^^^
     attr_reader :value
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -5398,6 +5830,15 @@ module Prism
     def self.type
       :constant_path_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ConstantPathWriteNode) &&
+        (target === other.target) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value)
+    end
   end
 
   # Represents referencing a constant.
@@ -5453,7 +5894,6 @@ module Prism
     #     SOME_CONSTANT  # name `:SOME_CONSTANT`
     attr_reader :name
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -5488,6 +5928,13 @@ module Prism
     def self.type
       :constant_read_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ConstantReadNode) &&
+        (name === other.name)
+    end
   end
 
   # Represents writing to a constant in a context that doesn't have an explicit value.
@@ -5539,7 +5986,6 @@ module Prism
     # attr_reader name: Symbol
     attr_reader :name
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -5574,6 +6020,13 @@ module Prism
     def self.type
       :constant_target_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ConstantTargetNode) &&
+        (name === other.name)
+    end
   end
 
   # Represents writing to a constant.
@@ -5625,27 +6078,42 @@ module Prism
       { name: name, name_loc: name_loc, value: value, operator_loc: operator_loc, location: location }
     end
 
-    # attr_reader name: Symbol
+    # The name of the [constant](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#constants).
+    #
+    #     Foo = :bar # name `:Foo`
+    #
+    #     XYZ = 1    # name `:XYZ`
     attr_reader :name
 
-    # attr_reader name_loc: Location
+    # The location of the constant name.
+    #
+    #     FOO = 1
+    #     ^^^
     def name_loc
       location = @name_loc
       return location if location.is_a?(Location)
       @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-    # attr_reader value: Prism::node
+    # The value to write to the constant. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+    #
+    #     FOO = :bar
+    #           ^^^^
+    #
+    #     MyClass = Class.new
+    #               ^^^^^^^^^
     attr_reader :value
 
-    # attr_reader operator_loc: Location
+    # The location of the `=` operator.
+    #
+    #     FOO = :bar
+    #         ^
     def operator_loc
       location = @operator_loc
       return location if location.is_a?(Location)
       @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -5689,6 +6157,16 @@ module Prism
     def self.type
       :constant_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ConstantWriteNode) &&
+        (name === other.name) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (value === other.value) &&
+        (operator_loc.nil? == other.operator_loc.nil?)
+    end
   end
 
   # Represents a method definition.
@@ -5847,7 +6325,6 @@ module Prism
       end
     end
 
-
     # def def_keyword: () -> String
     def def_keyword
       def_keyword_loc.slice
@@ -5938,6 +6415,25 @@ module Prism
     def self.type
       :def_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(DefNode) &&
+        (name === other.name) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (receiver === other.receiver) &&
+        (parameters === other.parameters) &&
+        (body === other.body) &&
+        (locals.length == other.locals.length) &&
+        locals.zip(other.locals).all? { |left, right| left === right } &&
+        (def_keyword_loc.nil? == other.def_keyword_loc.nil?) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (lparen_loc.nil? == other.lparen_loc.nil?) &&
+        (rparen_loc.nil? == other.rparen_loc.nil?) &&
+        (equal_loc.nil? == other.equal_loc.nil?) &&
+        (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
+    end
   end
 
   # Represents the use of the `defined?` keyword.
@@ -6025,7 +6521,6 @@ module Prism
       @keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def lparen: () -> String?
     def lparen
       lparen_loc&.slice
@@ -6079,6 +6574,16 @@ module Prism
     def self.type
       :defined_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(DefinedNode) &&
+        (lparen_loc.nil? == other.lparen_loc.nil?) &&
+        (value === other.value) &&
+        (rparen_loc.nil? == other.rparen_loc.nil?) &&
+        (keyword_loc.nil? == other.keyword_loc.nil?)
+    end
   end
 
   # Represents an `else` clause in a `case`, `if`, or `unless` statement.
@@ -6154,7 +6659,6 @@ module Prism
       end
     end
 
-
     # def else_keyword: () -> String
     def else_keyword
       else_keyword_loc.slice
@@ -6206,6 +6710,15 @@ module Prism
     def self.type
       :else_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ElseNode) &&
+        (else_keyword_loc.nil? == other.else_keyword_loc.nil?) &&
+        (statements === other.statements) &&
+        (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
+    end
   end
 
   # Represents an interpolated set of statements.
@@ -6275,7 +6788,6 @@ module Prism
       @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def opening: () -> String
     def opening
       opening_loc.slice
@@ -6327,6 +6839,15 @@ module Prism
     def self.type
       :embedded_statements_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(EmbeddedStatementsNode) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (statements === other.statements) &&
+        (closing_loc.nil? == other.closing_loc.nil?)
+    end
   end
 
   # Represents an interpolated variable.
@@ -6386,7 +6907,6 @@ module Prism
     # attr_reader variable: Prism::node
     attr_reader :variable
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -6428,6 +6948,14 @@ module Prism
     def self.type
       :embedded_variable_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(EmbeddedVariableNode) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (variable === other.variable)
+    end
   end
 
   # Represents an `ensure` clause in a `begin` statement.
@@ -6501,7 +7029,6 @@ module Prism
       @end_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def ensure_keyword: () -> String
     def ensure_keyword
       ensure_keyword_loc.slice
@@ -6553,6 +7080,15 @@ module Prism
     def self.type
       :ensure_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(EnsureNode) &&
+        (ensure_keyword_loc.nil? == other.ensure_keyword_loc.nil?) &&
+        (statements === other.statements) &&
+        (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
+    end
   end
 
   # Represents the use of the literal `false` keyword.
@@ -6600,7 +7136,6 @@ module Prism
       { location: location }
     end
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -6634,6 +7169,12 @@ module Prism
     def self.type
       :false_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(FalseNode)
+    end
   end
 
   # Represents a find pattern in pattern matching.
@@ -6736,7 +7277,6 @@ module Prism
       end
     end
 
-
     # def opening: () -> String?
     def opening
       opening_loc&.slice
@@ -6793,6 +7333,19 @@ module Prism
     def self.type
       :find_pattern_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(FindPatternNode) &&
+        (constant === other.constant) &&
+        (left === other.left) &&
+        (requireds.length == other.requireds.length) &&
+        requireds.zip(other.requireds).all? { |left, right| left === right } &&
+        (right === other.right) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (closing_loc.nil? == other.closing_loc.nil?)
+    end
   end
 
   # Represents the use of the `..` or `...` operators to create flip flops.
@@ -6847,9 +7400,9 @@ module Prism
       { flags: flags, left: left, right: right, operator_loc: operator_loc, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader left: Prism::node?
     attr_reader :left
@@ -6864,7 +7417,6 @@ module Prism
       @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def exclude_end?: () -> bool
     def exclude_end?
       flags.anybits?(RangeFlags::EXCLUDE_END)
@@ -6923,6 +7475,16 @@ module Prism
     def self.type
       :flip_flop_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(FlipFlopNode) &&
+        (flags === other.flags) &&
+        (left === other.left) &&
+        (right === other.right) &&
+        (operator_loc.nil? == other.operator_loc.nil?)
+    end
   end
 
   # Represents a floating point number literal.
@@ -6974,7 +7536,6 @@ module Prism
     # The value of the floating point number as a Float.
     attr_reader :value
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -7009,6 +7570,13 @@ module Prism
     def self.type
       :float_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(FloatNode) &&
+        (value === other.value)
+    end
   end
 
   # Represents the use of the `for` keyword.
@@ -7110,7 +7678,6 @@ module Prism
       @end_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def for_keyword: () -> String
     def for_keyword
       for_keyword_loc.slice
@@ -7178,6 +7745,19 @@ module Prism
     def self.type
       :for_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ForNode) &&
+        (index === other.index) &&
+        (collection === other.collection) &&
+        (statements === other.statements) &&
+        (for_keyword_loc.nil? == other.for_keyword_loc.nil?) &&
+        (in_keyword_loc.nil? == other.in_keyword_loc.nil?) &&
+        (do_keyword_loc.nil? == other.do_keyword_loc.nil?) &&
+        (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
+    end
   end
 
   # Represents forwarding all arguments to this method to another method.
@@ -7227,7 +7807,6 @@ module Prism
       { location: location }
     end
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -7261,6 +7840,12 @@ module Prism
     def self.type
       :forwarding_arguments_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ForwardingArgumentsNode)
+    end
   end
 
   # Represents the use of the forwarding parameter in a method, block, or lambda declaration.
@@ -7309,7 +7894,6 @@ module Prism
       { location: location }
     end
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -7343,6 +7927,12 @@ module Prism
     def self.type
       :forwarding_parameter_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ForwardingParameterNode)
+    end
   end
 
   # Represents the use of the `super` keyword without parentheses or arguments.
@@ -7396,7 +7986,6 @@ module Prism
     # attr_reader block: BlockNode?
     attr_reader :block
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -7436,6 +8025,13 @@ module Prism
     def self.type
       :forwarding_super_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ForwardingSuperNode) &&
+        (block === other.block)
+    end
   end
 
   # Represents the use of the `&&=` operator for assignment to a global variable.
@@ -7507,7 +8103,6 @@ module Prism
     # attr_reader value: Prism::node
     attr_reader :value
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -7551,6 +8146,16 @@ module Prism
     def self.type
       :global_variable_and_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(GlobalVariableAndWriteNode) &&
+        (name === other.name) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value)
+    end
   end
 
   # Represents assigning to a global variable using an operator that isn't `=`.
@@ -7626,7 +8231,6 @@ module Prism
     # attr_reader operator: Symbol
     attr_reader :operator
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -7666,6 +8270,17 @@ module Prism
     def self.type
       :global_variable_operator_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(GlobalVariableOperatorWriteNode) &&
+        (name === other.name) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value) &&
+        (operator === other.operator)
+    end
   end
 
   # Represents the use of the `||=` operator for assignment to a global variable.
@@ -7737,7 +8352,6 @@ module Prism
     # attr_reader value: Prism::node
     attr_reader :value
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -7781,6 +8395,16 @@ module Prism
     def self.type
       :global_variable_or_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(GlobalVariableOrWriteNode) &&
+        (name === other.name) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value)
+    end
   end
 
   # Represents referencing a global variable.
@@ -7836,7 +8460,6 @@ module Prism
     #     $_Test # name `:$_Test`
     attr_reader :name
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -7871,6 +8494,13 @@ module Prism
     def self.type
       :global_variable_read_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(GlobalVariableReadNode) &&
+        (name === other.name)
+    end
   end
 
   # Represents writing to a global variable in a context that doesn't have an explicit value.
@@ -7922,7 +8552,6 @@ module Prism
     # attr_reader name: Symbol
     attr_reader :name
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -7957,6 +8586,13 @@ module Prism
     def self.type
       :global_variable_target_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(GlobalVariableTargetNode) &&
+        (name === other.name)
+    end
   end
 
   # Represents writing to a global variable.
@@ -8008,27 +8644,42 @@ module Prism
       { name: name, name_loc: name_loc, value: value, operator_loc: operator_loc, location: location }
     end
 
-    # attr_reader name: Symbol
+    # The name of the global variable, which is a `$` followed by an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifier). Alternatively, it can be one of the special global variables designated by a symbol.
+    #
+    #     $foo = :bar  # name `:$foo`
+    #
+    #     $_Test = 123 # name `:$_Test`
     attr_reader :name
 
-    # attr_reader name_loc: Location
+    # The location of the global variable's name.
+    #
+    #     $foo = :bar
+    #     ^^^^
     def name_loc
       location = @name_loc
       return location if location.is_a?(Location)
       @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-    # attr_reader value: Prism::node
+    # The value to write to the global variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+    #
+    #     $foo = :bar
+    #            ^^^^
+    #
+    #     $-xyz = 123
+    #             ^^^
     attr_reader :value
 
-    # attr_reader operator_loc: Location
+    # The location of the `=` operator.
+    #
+    #     $foo = :bar
+    #          ^
     def operator_loc
       location = @operator_loc
       return location if location.is_a?(Location)
       @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -8072,6 +8723,16 @@ module Prism
     def self.type
       :global_variable_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(GlobalVariableWriteNode) &&
+        (name === other.name) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (value === other.value) &&
+        (operator_loc.nil? == other.operator_loc.nil?)
+    end
   end
 
   # Represents a hash literal.
@@ -8151,7 +8812,6 @@ module Prism
       @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def opening: () -> String
     def opening
       opening_loc.slice
@@ -8198,6 +8858,16 @@ module Prism
     def self.type
       :hash_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(HashNode) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (elements.length == other.elements.length) &&
+        elements.zip(other.elements).all? { |left, right| left === right } &&
+        (closing_loc.nil? == other.closing_loc.nil?)
+    end
   end
 
   # Represents a hash pattern in pattern matching.
@@ -8292,7 +8962,6 @@ module Prism
       end
     end
 
-
     # def opening: () -> String?
     def opening
       opening_loc&.slice
@@ -8351,15 +9020,30 @@ module Prism
     def self.type
       :hash_pattern_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(HashPatternNode) &&
+        (constant === other.constant) &&
+        (elements.length == other.elements.length) &&
+        elements.zip(other.elements).all? { |left, right| left === right } &&
+        (rest === other.rest) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (closing_loc.nil? == other.closing_loc.nil?)
+    end
   end
 
-  # Represents the use of the `if` keyword, either in the block form or the modifier form.
+  # Represents the use of the `if` keyword, either in the block form or the modifier form, or a ternary expression.
   #
   #     bar if foo
   #     ^^^^^^^^^^
   #
   #     if foo then bar end
   #     ^^^^^^^^^^^^^^^^^^^
+  #
+  #     foo ? bar : baz
+  #     ^^^^^^^^^^^^^^^
   class IfNode < Node
     # def initialize: (Location? if_keyword_loc, Prism::node predicate, Location? then_keyword_loc, StatementsNode? statements, Prism::node? consequent, Location? end_keyword_loc, Location location) -> void
     def initialize(source, if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location)
@@ -8415,7 +9099,12 @@ module Prism
       { if_keyword_loc: if_keyword_loc, predicate: predicate, then_keyword_loc: then_keyword_loc, statements: statements, consequent: consequent, end_keyword_loc: end_keyword_loc, location: location }
     end
 
-    # attr_reader if_keyword_loc: Location?
+    # The location of the `if` keyword if present.
+    #
+    #     bar if foo
+    #         ^^
+    #
+    # The `if_keyword_loc` field will be `nil` when the `IfNode` represents a ternary expression.
     def if_keyword_loc
       location = @if_keyword_loc
       case location
@@ -8428,10 +9117,27 @@ module Prism
       end
     end
 
-    # attr_reader predicate: Prism::node
+    # The node for the condition the `IfNode` is testing.
+    #
+    #     if foo
+    #        ^^^
+    #       bar
+    #     end
+    #
+    #     bar if foo
+    #            ^^^
+    #
+    #     foo ? bar : baz
+    #     ^^^
     attr_reader :predicate
 
-    # attr_reader then_keyword_loc: Location?
+    # The location of the `then` keyword (if present) or the `?` in a ternary expression, `nil` otherwise.
+    #
+    #     if foo then bar end
+    #            ^^^^
+    #
+    #     a ? b : c
+    #       ^
     def then_keyword_loc
       location = @then_keyword_loc
       case location
@@ -8444,13 +9150,37 @@ module Prism
       end
     end
 
-    # attr_reader statements: StatementsNode?
+    # Represents the body of statements that will be executed when the predicate is evaluated as truthy. Will be `nil` when no body is provided.
+    #
+    #     if foo
+    #       bar
+    #       ^^^
+    #       baz
+    #       ^^^
+    #     end
     attr_reader :statements
 
-    # attr_reader consequent: Prism::node?
+    # Represents an `ElseNode` or an `IfNode` when there is an `else` or an `elsif` in the `if` statement.
+    #
+    #     if foo
+    #       bar
+    #     elsif baz
+    #     ^^^^^^^^^
+    #       qux
+    #       ^^^
+    #     end
+    #     ^^^
+    #
+    #     if foo then bar else baz end
+    #                     ^^^^^^^^^^^^
     attr_reader :consequent
 
-    # attr_reader end_keyword_loc: Location?
+    # The location of the `end` keyword if present, `nil` otherwise.
+    #
+    #     if foo
+    #       bar
+    #     end
+    #     ^^^
     def end_keyword_loc
       location = @end_keyword_loc
       case location
@@ -8463,7 +9193,6 @@ module Prism
       end
     end
 
-
     # def if_keyword: () -> String?
     def if_keyword
       if_keyword_loc&.slice
@@ -8529,6 +9258,18 @@ module Prism
     def self.type
       :if_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(IfNode) &&
+        (if_keyword_loc.nil? == other.if_keyword_loc.nil?) &&
+        (predicate === other.predicate) &&
+        (then_keyword_loc.nil? == other.then_keyword_loc.nil?) &&
+        (statements === other.statements) &&
+        (consequent === other.consequent) &&
+        (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
+    end
   end
 
   # Represents an imaginary number literal.
@@ -8580,7 +9321,6 @@ module Prism
     # attr_reader numeric: FloatNode | IntegerNode | RationalNode
     attr_reader :numeric
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -8616,6 +9356,13 @@ module Prism
     def self.type
       :imaginary_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ImaginaryNode) &&
+        (numeric === other.numeric)
+    end
   end
 
   # Represents a node that is implicitly being added to the tree but doesn't correspond directly to a node in the source.
@@ -8673,7 +9420,6 @@ module Prism
     # attr_reader value: Prism::node
     attr_reader :value
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -8709,6 +9455,13 @@ module Prism
     def self.type
       :implicit_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ImplicitNode) &&
+        (value === other.value)
+    end
   end
 
   # Represents using a trailing comma to indicate an implicit rest parameter.
@@ -8765,7 +9518,6 @@ module Prism
       { location: location }
     end
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -8799,6 +9551,12 @@ module Prism
     def self.type
       :implicit_rest_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ImplicitRestNode)
+    end
   end
 
   # Represents the use of the `in` keyword in a case statement.
@@ -8879,7 +9637,6 @@ module Prism
       end
     end
 
-
     # def in: () -> String
     def in
       in_loc.slice
@@ -8933,6 +9690,16 @@ module Prism
     def self.type
       :in_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(InNode) &&
+        (pattern === other.pattern) &&
+        (statements === other.statements) &&
+        (in_loc.nil? == other.in_loc.nil?) &&
+        (then_loc.nil? == other.then_loc.nil?)
+    end
   end
 
   # Represents the use of the `&&=` operator on a call to the `[]` method.
@@ -8994,9 +9761,9 @@ module Prism
       { flags: flags, receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, operator_loc: operator_loc, value: value, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader receiver: Prism::node?
     attr_reader :receiver
@@ -9044,7 +9811,6 @@ module Prism
     # attr_reader value: Prism::node
     attr_reader :value
 
-
     # def safe_navigation?: () -> bool
     def safe_navigation?
       flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -9144,6 +9910,21 @@ module Prism
     def self.type
       :index_and_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(IndexAndWriteNode) &&
+        (flags === other.flags) &&
+        (receiver === other.receiver) &&
+        (call_operator_loc.nil? == other.call_operator_loc.nil?) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (arguments === other.arguments) &&
+        (closing_loc.nil? == other.closing_loc.nil?) &&
+        (block === other.block) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value)
+    end
   end
 
   # Represents the use of an assignment operator on a call to `[]`.
@@ -9206,9 +9987,9 @@ module Prism
       { flags: flags, receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, operator: operator, operator_loc: operator_loc, value: value, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader receiver: Prism::node?
     attr_reader :receiver
@@ -9259,7 +10040,6 @@ module Prism
     # attr_reader value: Prism::node
     attr_reader :value
 
-
     # def safe_navigation?: () -> bool
     def safe_navigation?
       flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -9355,6 +10135,22 @@ module Prism
     def self.type
       :index_operator_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(IndexOperatorWriteNode) &&
+        (flags === other.flags) &&
+        (receiver === other.receiver) &&
+        (call_operator_loc.nil? == other.call_operator_loc.nil?) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (arguments === other.arguments) &&
+        (closing_loc.nil? == other.closing_loc.nil?) &&
+        (block === other.block) &&
+        (operator === other.operator) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value)
+    end
   end
 
   # Represents the use of the `||=` operator on a call to `[]`.
@@ -9416,9 +10212,9 @@ module Prism
       { flags: flags, receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, operator_loc: operator_loc, value: value, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader receiver: Prism::node?
     attr_reader :receiver
@@ -9466,7 +10262,6 @@ module Prism
     # attr_reader value: Prism::node
     attr_reader :value
 
-
     # def safe_navigation?: () -> bool
     def safe_navigation?
       flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -9566,6 +10361,21 @@ module Prism
     def self.type
       :index_or_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(IndexOrWriteNode) &&
+        (flags === other.flags) &&
+        (receiver === other.receiver) &&
+        (call_operator_loc.nil? == other.call_operator_loc.nil?) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (arguments === other.arguments) &&
+        (closing_loc.nil? == other.closing_loc.nil?) &&
+        (block === other.block) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value)
+    end
   end
 
   # Represents assigning to an index.
@@ -9631,9 +10441,9 @@ module Prism
       { flags: flags, receiver: receiver, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader receiver: Prism::node
     attr_reader :receiver
@@ -9658,7 +10468,6 @@ module Prism
     # attr_reader block: Prism::node?
     attr_reader :block
 
-
     # def safe_navigation?: () -> bool
     def safe_navigation?
       flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -9740,6 +10549,18 @@ module Prism
     def self.type
       :index_target_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(IndexTargetNode) &&
+        (flags === other.flags) &&
+        (receiver === other.receiver) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (arguments === other.arguments) &&
+        (closing_loc.nil? == other.closing_loc.nil?) &&
+        (block === other.block)
+    end
   end
 
   # Represents the use of the `&&=` operator for assignment to an instance variable.
@@ -9811,7 +10632,6 @@ module Prism
     # attr_reader value: Prism::node
     attr_reader :value
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -9855,6 +10675,16 @@ module Prism
     def self.type
       :instance_variable_and_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(InstanceVariableAndWriteNode) &&
+        (name === other.name) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value)
+    end
   end
 
   # Represents assigning to an instance variable using an operator that isn't `=`.
@@ -9930,7 +10760,6 @@ module Prism
     # attr_reader operator: Symbol
     attr_reader :operator
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -9970,6 +10799,17 @@ module Prism
     def self.type
       :instance_variable_operator_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(InstanceVariableOperatorWriteNode) &&
+        (name === other.name) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value) &&
+        (operator === other.operator)
+    end
   end
 
   # Represents the use of the `||=` operator for assignment to an instance variable.
@@ -10041,7 +10881,6 @@ module Prism
     # attr_reader value: Prism::node
     attr_reader :value
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -10085,6 +10924,16 @@ module Prism
     def self.type
       :instance_variable_or_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(InstanceVariableOrWriteNode) &&
+        (name === other.name) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value)
+    end
   end
 
   # Represents referencing an instance variable.
@@ -10140,7 +10989,6 @@ module Prism
     #     @_test # name `:@_test`
     attr_reader :name
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -10175,6 +11023,13 @@ module Prism
     def self.type
       :instance_variable_read_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(InstanceVariableReadNode) &&
+        (name === other.name)
+    end
   end
 
   # Represents writing to an instance variable in a context that doesn't have an explicit value.
@@ -10226,7 +11081,6 @@ module Prism
     # attr_reader name: Symbol
     attr_reader :name
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -10261,6 +11115,13 @@ module Prism
     def self.type
       :instance_variable_target_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(InstanceVariableTargetNode) &&
+        (name === other.name)
+    end
   end
 
   # Represents writing to an instance variable.
@@ -10329,8 +11190,7 @@ module Prism
       @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-    # The value to assign to the instance variable. Can be any node that
-    # represents a non-void expression.
+    # The value to write to the instance variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
     #     @foo = :bar
     #            ^^^^
@@ -10349,7 +11209,6 @@ module Prism
       @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -10393,6 +11252,16 @@ module Prism
     def self.type
       :instance_variable_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(InstanceVariableWriteNode) &&
+        (name === other.name) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (value === other.value) &&
+        (operator_loc.nil? == other.operator_loc.nil?)
+    end
   end
 
   # Represents an integer number literal.
@@ -10442,14 +11311,13 @@ module Prism
       { flags: flags, value: value, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # The value of the integer literal as a number.
     attr_reader :value
 
-
     # def binary?: () -> bool
     def binary?
       flags.anybits?(IntegerBaseFlags::BINARY)
@@ -10506,6 +11374,14 @@ module Prism
     def self.type
       :integer_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(IntegerNode) &&
+        (flags === other.flags) &&
+        (value === other.value)
+    end
   end
 
   # Represents a regular expression literal that contains interpolation that is being used in the predicate of a conditional to implicitly match against the last line read by an IO object.
@@ -10562,9 +11438,9 @@ module Prism
       { flags: flags, opening_loc: opening_loc, parts: parts, closing_loc: closing_loc, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader opening_loc: Location
     def opening_loc
@@ -10583,7 +11459,6 @@ module Prism
       @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def ignore_case?: () -> bool
     def ignore_case?
       flags.anybits?(RegularExpressionFlags::IGNORE_CASE)
@@ -10687,6 +11562,17 @@ module Prism
     def self.type
       :interpolated_match_last_line_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(InterpolatedMatchLastLineNode) &&
+        (flags === other.flags) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (parts.length == other.parts.length) &&
+        parts.zip(other.parts).all? { |left, right| left === right } &&
+        (closing_loc.nil? == other.closing_loc.nil?)
+    end
   end
 
   # Represents a regular expression literal that contains interpolation.
@@ -10743,9 +11629,9 @@ module Prism
       { flags: flags, opening_loc: opening_loc, parts: parts, closing_loc: closing_loc, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader opening_loc: Location
     def opening_loc
@@ -10764,7 +11650,6 @@ module Prism
       @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def ignore_case?: () -> bool
     def ignore_case?
       flags.anybits?(RegularExpressionFlags::IGNORE_CASE)
@@ -10868,6 +11753,17 @@ module Prism
     def self.type
       :interpolated_regular_expression_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(InterpolatedRegularExpressionNode) &&
+        (flags === other.flags) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (parts.length == other.parts.length) &&
+        parts.zip(other.parts).all? { |left, right| left === right } &&
+        (closing_loc.nil? == other.closing_loc.nil?)
+    end
   end
 
   # Represents a string literal that contains interpolation.
@@ -10924,9 +11820,9 @@ module Prism
       { flags: flags, opening_loc: opening_loc, parts: parts, closing_loc: closing_loc, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader opening_loc: Location?
     def opening_loc
@@ -10957,7 +11853,6 @@ module Prism
       end
     end
 
-
     # def frozen?: () -> bool
     def frozen?
       flags.anybits?(InterpolatedStringNodeFlags::FROZEN)
@@ -11016,6 +11911,17 @@ module Prism
     def self.type
       :interpolated_string_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(InterpolatedStringNode) &&
+        (flags === other.flags) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (parts.length == other.parts.length) &&
+        parts.zip(other.parts).all? { |left, right| left === right } &&
+        (closing_loc.nil? == other.closing_loc.nil?)
+    end
   end
 
   # Represents a symbol literal that contains interpolation.
@@ -11100,7 +12006,6 @@ module Prism
       end
     end
 
-
     # def opening: () -> String?
     def opening
       opening_loc&.slice
@@ -11147,6 +12052,16 @@ module Prism
     def self.type
       :interpolated_symbol_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(InterpolatedSymbolNode) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (parts.length == other.parts.length) &&
+        parts.zip(other.parts).all? { |left, right| left === right } &&
+        (closing_loc.nil? == other.closing_loc.nil?)
+    end
   end
 
   # Represents an xstring literal that contains interpolation.
@@ -11219,7 +12134,6 @@ module Prism
       @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def opening: () -> String
     def opening
       opening_loc.slice
@@ -11266,6 +12180,16 @@ module Prism
     def self.type
       :interpolated_x_string_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(InterpolatedXStringNode) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (parts.length == other.parts.length) &&
+        parts.zip(other.parts).all? { |left, right| left === right } &&
+        (closing_loc.nil? == other.closing_loc.nil?)
+    end
   end
 
   # Represents an implicit set of parameters through the use of the `it` keyword within a block or lambda.
@@ -11313,7 +12237,6 @@ module Prism
       { location: location }
     end
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -11347,6 +12270,12 @@ module Prism
     def self.type
       :it_parameters_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ItParametersNode)
+    end
   end
 
   # Represents a hash literal without opening and closing braces.
@@ -11396,14 +12325,13 @@ module Prism
       { flags: flags, elements: elements, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader elements: Array[AssocNode | AssocSplatNode]
     attr_reader :elements
 
-
     # def symbol_keys?: () -> bool
     def symbol_keys?
       flags.anybits?(KeywordHashNodeFlags::SYMBOL_KEYS)
@@ -11445,6 +12373,15 @@ module Prism
     def self.type
       :keyword_hash_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(KeywordHashNode) &&
+        (flags === other.flags) &&
+        (elements.length == other.elements.length) &&
+        elements.zip(other.elements).all? { |left, right| left === right }
+    end
   end
 
   # Represents a keyword rest parameter to a method, block, or lambda definition.
@@ -11497,9 +12434,9 @@ module Prism
       { flags: flags, name: name, name_loc: name_loc, operator_loc: operator_loc, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader name: Symbol?
     attr_reader :name
@@ -11524,7 +12461,6 @@ module Prism
       @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def repeated_parameter?: () -> bool
     def repeated_parameter?
       flags.anybits?(ParameterFlags::REPEATED_PARAMETER)
@@ -11577,6 +12513,16 @@ module Prism
     def self.type
       :keyword_rest_parameter_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(KeywordRestParameterNode) &&
+        (flags === other.flags) &&
+        (name === other.name) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (operator_loc.nil? == other.operator_loc.nil?)
+    end
   end
 
   # Represents using a lambda literal (not the lambda method call).
@@ -11663,7 +12609,6 @@ module Prism
     # attr_reader body: Prism::node?
     attr_reader :body
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -11728,6 +12673,19 @@ module Prism
     def self.type
       :lambda_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(LambdaNode) &&
+        (locals.length == other.locals.length) &&
+        locals.zip(other.locals).all? { |left, right| left === right } &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (closing_loc.nil? == other.closing_loc.nil?) &&
+        (parameters === other.parameters) &&
+        (body === other.body)
+    end
   end
 
   # Represents the use of the `&&=` operator for assignment to a local variable.
@@ -11803,7 +12761,6 @@ module Prism
     # attr_reader depth: Integer
     attr_reader :depth
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -11848,6 +12805,17 @@ module Prism
     def self.type
       :local_variable_and_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(LocalVariableAndWriteNode) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value) &&
+        (name === other.name) &&
+        (depth === other.depth)
+    end
   end
 
   # Represents assigning to a local variable using an operator that isn't `=`.
@@ -11927,7 +12895,6 @@ module Prism
     # attr_reader depth: Integer
     attr_reader :depth
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -11968,6 +12935,18 @@ module Prism
     def self.type
       :local_variable_operator_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(LocalVariableOperatorWriteNode) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value) &&
+        (name === other.name) &&
+        (operator === other.operator) &&
+        (depth === other.depth)
+    end
   end
 
   # Represents the use of the `||=` operator for assignment to a local variable.
@@ -12043,7 +13022,6 @@ module Prism
     # attr_reader depth: Integer
     attr_reader :depth
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -12088,6 +13066,17 @@ module Prism
     def self.type
       :local_variable_or_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(LocalVariableOrWriteNode) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value) &&
+        (name === other.name) &&
+        (depth === other.depth)
+    end
   end
 
   # Represents reading a local variable. Note that this requires that a local variable of the same name has already been written to in the same scope, otherwise it is parsed as a method call.
@@ -12161,7 +13150,6 @@ module Prism
     # The specific rules for calculating the depth may differ from individual Ruby implementations, as they are not specified by the language. For more information, see [the Prism documentation](https://github.com/ruby/prism/blob/main/docs/local_variable_depth.md).
     attr_reader :depth
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -12197,6 +13185,14 @@ module Prism
     def self.type
       :local_variable_read_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(LocalVariableReadNode) &&
+        (name === other.name) &&
+        (depth === other.depth)
+    end
   end
 
   # Represents writing to a local variable in a context that doesn't have an explicit value.
@@ -12252,7 +13248,6 @@ module Prism
     # attr_reader depth: Integer
     attr_reader :depth
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -12288,6 +13283,14 @@ module Prism
     def self.type
       :local_variable_target_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(LocalVariableTargetNode) &&
+        (name === other.name) &&
+        (depth === other.depth)
+    end
   end
 
   # Represents writing to a local variable.
@@ -12340,30 +13343,55 @@ module Prism
       { name: name, depth: depth, name_loc: name_loc, value: value, operator_loc: operator_loc, location: location }
     end
 
-    # attr_reader name: Symbol
+    # The name of the local variable, which is an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
+    #
+    #     foo = :bar # name `:foo`
+    #
+    #     abc = 123  # name `:abc`
     attr_reader :name
 
-    # attr_reader depth: Integer
+    # The number of semantic scopes we have to traverse to find the declaration of this variable.
+    #
+    #     foo = 1         # depth 0
+    #
+    #     tap { foo = 1 } # depth 1
+    #
+    # The specific rules for calculating the depth may differ from individual Ruby implementations, as they are not specified by the language. For more information, see [the Prism documentation](https://github.com/ruby/prism/blob/main/docs/local_variable_depth.md).
     attr_reader :depth
 
-    # attr_reader name_loc: Location
+    # The location of the variable name.
+    #
+    #     foo = :bar
+    #     ^^^
     def name_loc
       location = @name_loc
       return location if location.is_a?(Location)
       @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-    # attr_reader value: Prism::node
+    # The value to write to the local variable. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+    #
+    #     foo = :bar
+    #           ^^^^
+    #
+    #     abc = 1234
+    #           ^^^^
+    #
+    # Note that since the name of a local variable is known before the value is parsed, it is valid for a local variable to appear within the value of its own write.
+    #
+    #     foo = foo
     attr_reader :value
 
-    # attr_reader operator_loc: Location
+    # The location of the `=` operator.
+    #
+    #     x = :y
+    #       ^
     def operator_loc
       location = @operator_loc
       return location if location.is_a?(Location)
       @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -12408,6 +13436,17 @@ module Prism
     def self.type
       :local_variable_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(LocalVariableWriteNode) &&
+        (name === other.name) &&
+        (depth === other.depth) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (value === other.value) &&
+        (operator_loc.nil? == other.operator_loc.nil?)
+    end
   end
 
   # Represents a regular expression literal used in the predicate of a conditional to implicitly match against the last line read by an IO object.
@@ -12460,9 +13499,9 @@ module Prism
       { flags: flags, opening_loc: opening_loc, content_loc: content_loc, closing_loc: closing_loc, unescaped: unescaped, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader opening_loc: Location
     def opening_loc
@@ -12488,7 +13527,6 @@ module Prism
     # attr_reader unescaped: String
     attr_reader :unescaped
 
-
     # def ignore_case?: () -> bool
     def ignore_case?
       flags.anybits?(RegularExpressionFlags::IGNORE_CASE)
@@ -12598,6 +13636,17 @@ module Prism
     def self.type
       :match_last_line_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(MatchLastLineNode) &&
+        (flags === other.flags) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (content_loc.nil? == other.content_loc.nil?) &&
+        (closing_loc.nil? == other.closing_loc.nil?) &&
+        (unescaped === other.unescaped)
+    end
   end
 
   # Represents the use of the modifier `in` operator.
@@ -12661,7 +13710,6 @@ module Prism
       @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -12705,6 +13753,15 @@ module Prism
     def self.type
       :match_predicate_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(MatchPredicateNode) &&
+        (value === other.value) &&
+        (pattern === other.pattern) &&
+        (operator_loc.nil? == other.operator_loc.nil?)
+    end
   end
 
   # Represents the use of the `=>` operator.
@@ -12768,7 +13825,6 @@ module Prism
       @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -12812,6 +13868,15 @@ module Prism
     def self.type
       :match_required_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(MatchRequiredNode) &&
+        (value === other.value) &&
+        (pattern === other.pattern) &&
+        (operator_loc.nil? == other.operator_loc.nil?)
+    end
   end
 
   # Represents writing local variables using a regular expression match with named capture groups.
@@ -12867,7 +13932,6 @@ module Prism
     # attr_reader targets: Array[LocalVariableTargetNode]
     attr_reader :targets
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -12904,6 +13968,15 @@ module Prism
     def self.type
       :match_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(MatchWriteNode) &&
+        (call === other.call) &&
+        (targets.length == other.targets.length) &&
+        targets.zip(other.targets).all? { |left, right| left === right }
+    end
   end
 
   # Represents a node that is missing from the source and results in a syntax error.
@@ -12948,7 +14021,6 @@ module Prism
       { location: location }
     end
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -12982,6 +14054,12 @@ module Prism
     def self.type
       :missing_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(MissingNode)
+    end
   end
 
   # Represents a module declaration involving the `module` keyword.
@@ -13064,7 +14142,6 @@ module Prism
     # attr_reader name: Symbol
     attr_reader :name
 
-
     # def module_keyword: () -> String
     def module_keyword
       module_keyword_loc.slice
@@ -13120,6 +14197,19 @@ module Prism
     def self.type
       :module_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ModuleNode) &&
+        (locals.length == other.locals.length) &&
+        locals.zip(other.locals).all? { |left, right| left === right } &&
+        (module_keyword_loc.nil? == other.module_keyword_loc.nil?) &&
+        (constant_path === other.constant_path) &&
+        (body === other.body) &&
+        (end_keyword_loc.nil? == other.end_keyword_loc.nil?) &&
+        (name === other.name)
+    end
   end
 
   # Represents a multi-target expression.
@@ -13211,7 +14301,6 @@ module Prism
       end
     end
 
-
     # def lparen: () -> String?
     def lparen
       lparen_loc&.slice
@@ -13265,6 +14354,19 @@ module Prism
     def self.type
       :multi_target_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(MultiTargetNode) &&
+        (lefts.length == other.lefts.length) &&
+        lefts.zip(other.lefts).all? { |left, right| left === right } &&
+        (rest === other.rest) &&
+        (rights.length == other.rights.length) &&
+        rights.zip(other.rights).all? { |left, right| left === right } &&
+        (lparen_loc.nil? == other.lparen_loc.nil?) &&
+        (rparen_loc.nil? == other.rparen_loc.nil?)
+    end
   end
 
   # Represents a write to a multi-target expression.
@@ -13369,7 +14471,6 @@ module Prism
     # attr_reader value: Prism::node
     attr_reader :value
 
-
     # def lparen: () -> String?
     def lparen
       lparen_loc&.slice
@@ -13431,6 +14532,21 @@ module Prism
     def self.type
       :multi_write_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(MultiWriteNode) &&
+        (lefts.length == other.lefts.length) &&
+        lefts.zip(other.lefts).all? { |left, right| left === right } &&
+        (rest === other.rest) &&
+        (rights.length == other.rights.length) &&
+        rights.zip(other.rights).all? { |left, right| left === right } &&
+        (lparen_loc.nil? == other.lparen_loc.nil?) &&
+        (rparen_loc.nil? == other.rparen_loc.nil?) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value)
+    end
   end
 
   # Represents the use of the `next` keyword.
@@ -13492,7 +14608,6 @@ module Prism
       @keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def keyword: () -> String
     def keyword
       keyword_loc.slice
@@ -13538,6 +14653,14 @@ module Prism
     def self.type
       :next_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(NextNode) &&
+        (arguments === other.arguments) &&
+        (keyword_loc.nil? == other.keyword_loc.nil?)
+    end
   end
 
   # Represents the use of the `nil` keyword.
@@ -13585,7 +14708,6 @@ module Prism
       { location: location }
     end
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -13619,6 +14741,12 @@ module Prism
     def self.type
       :nil_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(NilNode)
+    end
   end
 
   # Represents the use of `**nil` inside method arguments.
@@ -13683,7 +14811,6 @@ module Prism
       @keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -13729,6 +14856,14 @@ module Prism
     def self.type
       :no_keywords_parameter_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(NoKeywordsParameterNode) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (keyword_loc.nil? == other.keyword_loc.nil?)
+    end
   end
 
   # Represents an implicit set of parameters through the use of numbered parameters within a block or lambda.
@@ -13780,7 +14915,6 @@ module Prism
     # attr_reader maximum: Integer
     attr_reader :maximum
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -13815,6 +14949,13 @@ module Prism
     def self.type
       :numbered_parameters_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(NumberedParametersNode) &&
+        (maximum === other.maximum)
+    end
   end
 
   # Represents reading a numbered reference to a capture in the previous match.
@@ -13872,7 +15013,6 @@ module Prism
     #     $4294967296 # number `0`
     attr_reader :number
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -13907,6 +15047,13 @@ module Prism
     def self.type
       :numbered_reference_read_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(NumberedReferenceReadNode) &&
+        (number === other.number)
+    end
   end
 
   # Represents an optional keyword parameter to a method, block, or lambda definition.
@@ -13959,9 +15106,9 @@ module Prism
       { flags: flags, name: name, name_loc: name_loc, value: value, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader name: Symbol
     attr_reader :name
@@ -13976,7 +15123,6 @@ module Prism
     # attr_reader value: Prism::node
     attr_reader :value
 
-
     # def repeated_parameter?: () -> bool
     def repeated_parameter?
       flags.anybits?(ParameterFlags::REPEATED_PARAMETER)
@@ -14021,6 +15167,16 @@ module Prism
     def self.type
       :optional_keyword_parameter_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(OptionalKeywordParameterNode) &&
+        (flags === other.flags) &&
+        (name === other.name) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (value === other.value)
+    end
   end
 
   # Represents an optional parameter to a method, block, or lambda definition.
@@ -14074,9 +15230,9 @@ module Prism
       { flags: flags, name: name, name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader name: Symbol
     attr_reader :name
@@ -14098,7 +15254,6 @@ module Prism
     # attr_reader value: Prism::node
     attr_reader :value
 
-
     # def repeated_parameter?: () -> bool
     def repeated_parameter?
       flags.anybits?(ParameterFlags::REPEATED_PARAMETER)
@@ -14149,6 +15304,17 @@ module Prism
     def self.type
       :optional_parameter_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(OptionalParameterNode) &&
+        (flags === other.flags) &&
+        (name === other.name) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (value === other.value)
+    end
   end
 
   # Represents the use of the `||` operator or the `or` keyword.
@@ -14227,7 +15393,6 @@ module Prism
       @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -14271,6 +15436,15 @@ module Prism
     def self.type
       :or_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(OrNode) &&
+        (left === other.left) &&
+        (right === other.right) &&
+        (operator_loc.nil? == other.operator_loc.nil?)
+    end
   end
 
   # Represents the list of parameters on a method, block, or lambda definition.
@@ -14355,7 +15529,6 @@ module Prism
     # attr_reader block: BlockParameterNode?
     attr_reader :block
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -14411,6 +15584,23 @@ module Prism
     def self.type
       :parameters_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ParametersNode) &&
+        (requireds.length == other.requireds.length) &&
+        requireds.zip(other.requireds).all? { |left, right| left === right } &&
+        (optionals.length == other.optionals.length) &&
+        optionals.zip(other.optionals).all? { |left, right| left === right } &&
+        (rest === other.rest) &&
+        (posts.length == other.posts.length) &&
+        posts.zip(other.posts).all? { |left, right| left === right } &&
+        (keywords.length == other.keywords.length) &&
+        keywords.zip(other.keywords).all? { |left, right| left === right } &&
+        (keyword_rest === other.keyword_rest) &&
+        (block === other.block)
+    end
   end
 
   # Represents a parenthesized expression
@@ -14484,7 +15674,6 @@ module Prism
       @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def opening: () -> String
     def opening
       opening_loc.slice
@@ -14536,6 +15725,15 @@ module Prism
     def self.type
       :parentheses_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ParenthesesNode) &&
+        (body === other.body) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (closing_loc.nil? == other.closing_loc.nil?)
+    end
   end
 
   # Represents the use of the `^` operator for pinning an expression in a pattern matching expression.
@@ -14611,7 +15809,6 @@ module Prism
       @rparen_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -14665,6 +15862,16 @@ module Prism
     def self.type
       :pinned_expression_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(PinnedExpressionNode) &&
+        (expression === other.expression) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (lparen_loc.nil? == other.lparen_loc.nil?) &&
+        (rparen_loc.nil? == other.rparen_loc.nil?)
+    end
   end
 
   # Represents the use of the `^` operator for pinning a variable in a pattern matching expression.
@@ -14724,7 +15931,6 @@ module Prism
       @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -14766,6 +15972,14 @@ module Prism
     def self.type
       :pinned_variable_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(PinnedVariableNode) &&
+        (variable === other.variable) &&
+        (operator_loc.nil? == other.operator_loc.nil?)
+    end
   end
 
   # Represents the use of the `END` keyword.
@@ -14843,7 +16057,6 @@ module Prism
       @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def keyword: () -> String
     def keyword
       keyword_loc.slice
@@ -14901,6 +16114,16 @@ module Prism
     def self.type
       :post_execution_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(PostExecutionNode) &&
+        (statements === other.statements) &&
+        (keyword_loc.nil? == other.keyword_loc.nil?) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (closing_loc.nil? == other.closing_loc.nil?)
+    end
   end
 
   # Represents the use of the `BEGIN` keyword.
@@ -14978,7 +16201,6 @@ module Prism
       @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def keyword: () -> String
     def keyword
       keyword_loc.slice
@@ -15036,6 +16258,16 @@ module Prism
     def self.type
       :pre_execution_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(PreExecutionNode) &&
+        (statements === other.statements) &&
+        (keyword_loc.nil? == other.keyword_loc.nil?) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (closing_loc.nil? == other.closing_loc.nil?)
+    end
   end
 
   # The top level node of any parse tree.
@@ -15088,7 +16320,6 @@ module Prism
     # attr_reader statements: StatementsNode
     attr_reader :statements
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -15125,6 +16356,15 @@ module Prism
     def self.type
       :program_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ProgramNode) &&
+        (locals.length == other.locals.length) &&
+        locals.zip(other.locals).all? { |left, right| left === right } &&
+        (statements === other.statements)
+    end
   end
 
   # Represents the use of the `..` or `...` operators.
@@ -15182,9 +16422,9 @@ module Prism
       { flags: flags, left: left, right: right, operator_loc: operator_loc, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # The left-hand side of the range, if present. It can be either `nil` or any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
     #
@@ -15212,7 +16452,6 @@ module Prism
       @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def exclude_end?: () -> bool
     def exclude_end?
       flags.anybits?(RangeFlags::EXCLUDE_END)
@@ -15271,6 +16510,16 @@ module Prism
     def self.type
       :range_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(RangeNode) &&
+        (flags === other.flags) &&
+        (left === other.left) &&
+        (right === other.right) &&
+        (operator_loc.nil? == other.operator_loc.nil?)
+    end
   end
 
   # Represents a rational number literal.
@@ -15322,7 +16571,6 @@ module Prism
     # attr_reader numeric: Prism::node
     attr_reader :numeric
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -15358,6 +16606,13 @@ module Prism
     def self.type
       :rational_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(RationalNode) &&
+        (numeric === other.numeric)
+    end
   end
 
   # Represents the use of the `redo` keyword.
@@ -15405,7 +16660,6 @@ module Prism
       { location: location }
     end
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -15439,6 +16693,12 @@ module Prism
     def self.type
       :redo_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(RedoNode)
+    end
   end
 
   # Represents a regular expression literal with no interpolation.
@@ -15491,9 +16751,9 @@ module Prism
       { flags: flags, opening_loc: opening_loc, content_loc: content_loc, closing_loc: closing_loc, unescaped: unescaped, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader opening_loc: Location
     def opening_loc
@@ -15519,7 +16779,6 @@ module Prism
     # attr_reader unescaped: String
     attr_reader :unescaped
 
-
     # def ignore_case?: () -> bool
     def ignore_case?
       flags.anybits?(RegularExpressionFlags::IGNORE_CASE)
@@ -15629,6 +16888,17 @@ module Prism
     def self.type
       :regular_expression_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(RegularExpressionNode) &&
+        (flags === other.flags) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (content_loc.nil? == other.content_loc.nil?) &&
+        (closing_loc.nil? == other.closing_loc.nil?) &&
+        (unescaped === other.unescaped)
+    end
   end
 
   # Represents a required keyword parameter to a method, block, or lambda definition.
@@ -15680,9 +16950,9 @@ module Prism
       { flags: flags, name: name, name_loc: name_loc, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader name: Symbol
     attr_reader :name
@@ -15694,7 +16964,6 @@ module Prism
       @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def repeated_parameter?: () -> bool
     def repeated_parameter?
       flags.anybits?(ParameterFlags::REPEATED_PARAMETER)
@@ -15737,6 +17006,15 @@ module Prism
     def self.type
       :required_keyword_parameter_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(RequiredKeywordParameterNode) &&
+        (flags === other.flags) &&
+        (name === other.name) &&
+        (name_loc.nil? == other.name_loc.nil?)
+    end
   end
 
   # Represents a required parameter to a method, block, or lambda definition.
@@ -15787,14 +17065,13 @@ module Prism
       { flags: flags, name: name, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader name: Symbol
     attr_reader :name
 
-
     # def repeated_parameter?: () -> bool
     def repeated_parameter?
       flags.anybits?(ParameterFlags::REPEATED_PARAMETER)
@@ -15836,6 +17113,14 @@ module Prism
     def self.type
       :required_parameter_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(RequiredParameterNode) &&
+        (flags === other.flags) &&
+        (name === other.name)
+    end
   end
 
   # Represents an expression modified with a rescue.
@@ -15903,7 +17188,6 @@ module Prism
     # attr_reader rescue_expression: Prism::node
     attr_reader :rescue_expression
 
-
     # def keyword: () -> String
     def keyword
       keyword_loc.slice
@@ -15947,6 +17231,15 @@ module Prism
     def self.type
       :rescue_modifier_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(RescueModifierNode) &&
+        (expression === other.expression) &&
+        (keyword_loc.nil? == other.keyword_loc.nil?) &&
+        (rescue_expression === other.rescue_expression)
+    end
   end
 
   # Represents a rescue statement.
@@ -16042,7 +17335,6 @@ module Prism
     # attr_reader consequent: RescueNode?
     attr_reader :consequent
 
-
     # def keyword: () -> String
     def keyword
       keyword_loc.slice
@@ -16107,6 +17399,19 @@ module Prism
     def self.type
       :rescue_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(RescueNode) &&
+        (keyword_loc.nil? == other.keyword_loc.nil?) &&
+        (exceptions.length == other.exceptions.length) &&
+        exceptions.zip(other.exceptions).all? { |left, right| left === right } &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (reference === other.reference) &&
+        (statements === other.statements) &&
+        (consequent === other.consequent)
+    end
   end
 
   # Represents a rest parameter to a method, block, or lambda definition.
@@ -16159,9 +17464,9 @@ module Prism
       { flags: flags, name: name, name_loc: name_loc, operator_loc: operator_loc, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader name: Symbol?
     attr_reader :name
@@ -16186,7 +17491,6 @@ module Prism
       @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def repeated_parameter?: () -> bool
     def repeated_parameter?
       flags.anybits?(ParameterFlags::REPEATED_PARAMETER)
@@ -16239,6 +17543,16 @@ module Prism
     def self.type
       :rest_parameter_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(RestParameterNode) &&
+        (flags === other.flags) &&
+        (name === other.name) &&
+        (name_loc.nil? == other.name_loc.nil?) &&
+        (operator_loc.nil? == other.operator_loc.nil?)
+    end
   end
 
   # Represents the use of the `retry` keyword.
@@ -16286,7 +17600,6 @@ module Prism
       { location: location }
     end
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -16320,6 +17633,12 @@ module Prism
     def self.type
       :retry_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(RetryNode)
+    end
   end
 
   # Represents the use of the `return` keyword.
@@ -16381,7 +17700,6 @@ module Prism
     # attr_reader arguments: ArgumentsNode?
     attr_reader :arguments
 
-
     # def keyword: () -> String
     def keyword
       keyword_loc.slice
@@ -16427,6 +17745,14 @@ module Prism
     def self.type
       :return_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ReturnNode) &&
+        (keyword_loc.nil? == other.keyword_loc.nil?) &&
+        (arguments === other.arguments)
+    end
   end
 
   # Represents the `self` keyword.
@@ -16474,7 +17800,6 @@ module Prism
       { location: location }
     end
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -16508,6 +17833,12 @@ module Prism
     def self.type
       :self_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(SelfNode)
+    end
   end
 
   # This node wraps a constant write to indicate that when the value is written, it should have its shareability state modified.
@@ -16558,14 +17889,13 @@ module Prism
       { flags: flags, write: write, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # The constant write that should be modified with the shareability state.
     attr_reader :write
 
-
     # def literal?: () -> bool
     def literal?
       flags.anybits?(ShareableConstantNodeFlags::LITERAL)
@@ -16618,6 +17948,14 @@ module Prism
     def self.type
       :shareable_constant_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(ShareableConstantNode) &&
+        (flags === other.flags) &&
+        (write === other.write)
+    end
   end
 
   # Represents a singleton class declaration involving the `class` keyword.
@@ -16704,7 +18042,6 @@ module Prism
       @end_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def class_keyword: () -> String
     def class_keyword
       class_keyword_loc.slice
@@ -16765,6 +18102,19 @@ module Prism
     def self.type
       :singleton_class_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(SingletonClassNode) &&
+        (locals.length == other.locals.length) &&
+        locals.zip(other.locals).all? { |left, right| left === right } &&
+        (class_keyword_loc.nil? == other.class_keyword_loc.nil?) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (expression === other.expression) &&
+        (body === other.body) &&
+        (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
+    end
   end
 
   # Represents the use of the `__ENCODING__` keyword.
@@ -16812,7 +18162,6 @@ module Prism
       { location: location }
     end
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -16846,6 +18195,12 @@ module Prism
     def self.type
       :source_encoding_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(SourceEncodingNode)
+    end
   end
 
   # Represents the use of the `__FILE__` keyword.
@@ -16895,14 +18250,13 @@ module Prism
       { flags: flags, filepath: filepath, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
-    # attr_reader filepath: String
+    # Represents the file path being parsed. This corresponds directly to the `filepath` option given to the various `Prism::parse*` APIs.
     attr_reader :filepath
 
-
     # def forced_utf8_encoding?: () -> bool
     def forced_utf8_encoding?
       flags.anybits?(StringFlags::FORCED_UTF8_ENCODING)
@@ -16959,6 +18313,14 @@ module Prism
     def self.type
       :source_file_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(SourceFileNode) &&
+        (flags === other.flags) &&
+        (filepath === other.filepath)
+    end
   end
 
   # Represents the use of the `__LINE__` keyword.
@@ -17006,7 +18368,6 @@ module Prism
       { location: location }
     end
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -17040,6 +18401,12 @@ module Prism
     def self.type
       :source_line_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(SourceLineNode)
+    end
   end
 
   # Represents the use of the splat operator.
@@ -17101,7 +18468,6 @@ module Prism
     # attr_reader expression: Prism::node?
     attr_reader :expression
 
-
     # def operator: () -> String
     def operator
       operator_loc.slice
@@ -17147,6 +18513,14 @@ module Prism
     def self.type
       :splat_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(SplatNode) &&
+        (operator_loc.nil? == other.operator_loc.nil?) &&
+        (expression === other.expression)
+    end
   end
 
   # Represents a set of statements contained within some scope.
@@ -17198,7 +18572,6 @@ module Prism
     # attr_reader body: Array[Prism::node]
     attr_reader :body
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -17233,6 +18606,14 @@ module Prism
     def self.type
       :statements_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(StatementsNode) &&
+        (body.length == other.body.length) &&
+        body.zip(other.body).all? { |left, right| left === right }
+    end
   end
 
   # Represents a string literal, a string contained within a `%w` list, or plain string content within an interpolated string.
@@ -17291,9 +18672,9 @@ module Prism
       { flags: flags, opening_loc: opening_loc, content_loc: content_loc, closing_loc: closing_loc, unescaped: unescaped, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader opening_loc: Location?
     def opening_loc
@@ -17331,7 +18712,6 @@ module Prism
     # attr_reader unescaped: String
     attr_reader :unescaped
 
-
     # def forced_utf8_encoding?: () -> bool
     def forced_utf8_encoding?
       flags.anybits?(StringFlags::FORCED_UTF8_ENCODING)
@@ -17406,6 +18786,17 @@ module Prism
     def self.type
       :string_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(StringNode) &&
+        (flags === other.flags) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (content_loc.nil? == other.content_loc.nil?) &&
+        (closing_loc.nil? == other.closing_loc.nil?) &&
+        (unescaped === other.unescaped)
+    end
   end
 
   # Represents the use of the `super` keyword with parentheses or arguments.
@@ -17503,7 +18894,6 @@ module Prism
     # attr_reader block: Prism::node?
     attr_reader :block
 
-
     # def keyword: () -> String
     def keyword
       keyword_loc.slice
@@ -17567,6 +18957,17 @@ module Prism
     def self.type
       :super_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(SuperNode) &&
+        (keyword_loc.nil? == other.keyword_loc.nil?) &&
+        (lparen_loc.nil? == other.lparen_loc.nil?) &&
+        (arguments === other.arguments) &&
+        (rparen_loc.nil? == other.rparen_loc.nil?) &&
+        (block === other.block)
+    end
   end
 
   # Represents a symbol literal or a symbol contained within a `%i` list.
@@ -17622,9 +19023,9 @@ module Prism
       { flags: flags, opening_loc: opening_loc, value_loc: value_loc, closing_loc: closing_loc, unescaped: unescaped, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader opening_loc: Location?
     def opening_loc
@@ -17668,7 +19069,6 @@ module Prism
     # attr_reader unescaped: String
     attr_reader :unescaped
 
-
     # def forced_utf8_encoding?: () -> bool
     def forced_utf8_encoding?
       flags.anybits?(SymbolFlags::FORCED_UTF8_ENCODING)
@@ -17738,6 +19138,17 @@ module Prism
     def self.type
       :symbol_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(SymbolNode) &&
+        (flags === other.flags) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (value_loc.nil? == other.value_loc.nil?) &&
+        (closing_loc.nil? == other.closing_loc.nil?) &&
+        (unescaped === other.unescaped)
+    end
   end
 
   # Represents the use of the literal `true` keyword.
@@ -17785,7 +19196,6 @@ module Prism
       { location: location }
     end
 
-
     # def inspect(NodeInspector inspector) -> String
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
@@ -17819,6 +19229,12 @@ module Prism
     def self.type
       :true_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(TrueNode)
+    end
   end
 
   # Represents the use of the `undef` keyword.
@@ -17878,7 +19294,6 @@ module Prism
       @keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-
     # def keyword: () -> String
     def keyword
       keyword_loc.slice
@@ -17919,6 +19334,15 @@ module Prism
     def self.type
       :undef_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(UndefNode) &&
+        (names.length == other.names.length) &&
+        names.zip(other.names).all? { |left, right| left === right } &&
+        (keyword_loc.nil? == other.keyword_loc.nil?)
+    end
   end
 
   # Represents the use of the `unless` keyword, either in the block form or the modifier form.
@@ -17983,17 +19407,30 @@ module Prism
       { keyword_loc: keyword_loc, predicate: predicate, then_keyword_loc: then_keyword_loc, statements: statements, consequent: consequent, end_keyword_loc: end_keyword_loc, location: location }
     end
 
-    # attr_reader keyword_loc: Location
+    # The location of the `unless` keyword.
+    #
+    #     unless cond then bar end
+    #     ^^^^^^
+    #
+    #     bar unless cond
+    #         ^^^^^^
     def keyword_loc
       location = @keyword_loc
       return location if location.is_a?(Location)
       @keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
     end
 
-    # attr_reader predicate: Prism::node
+    # The condition to be evaluated for the unless expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
+    #
+    #     unless cond then bar end
+    #            ^^^^
+    #
+    #     bar unless cond
+    #                ^^^^
     attr_reader :predicate
 
-    # attr_reader then_keyword_loc: Location?
+    # The location of the `then` keyword, if present.
+    # unless cond then bar end ^^^^
     def then_keyword_loc
       location = @then_keyword_loc
       case location
@@ -18006,13 +19443,23 @@ module Prism
       end
     end
 
-    # attr_reader statements: StatementsNode?
+    # The body of statements that will executed if the unless condition is
+    # falsey. Will be `nil` if no body is provided.
+    #
+    #     unless cond then bar end
+    #                      ^^^
     attr_reader :statements
 
-    # attr_reader consequent: ElseNode?
+    # The else clause of the unless expression, if present.
+    #
+    #     unless cond then bar else baz end
+    #                          ^^^^^^^^
     attr_reader :consequent
 
-    # attr_reader end_keyword_loc: Location?
+    # The location of the `end` keyword, if present.
+    #
+    #     unless cond then bar end
+    #                          ^^^
     def end_keyword_loc
       location = @end_keyword_loc
       case location
@@ -18025,7 +19472,6 @@ module Prism
       end
     end
 
-
     # def keyword: () -> String
     def keyword
       keyword_loc.slice
@@ -18091,6 +19537,18 @@ module Prism
     def self.type
       :unless_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(UnlessNode) &&
+        (keyword_loc.nil? == other.keyword_loc.nil?) &&
+        (predicate === other.predicate) &&
+        (then_keyword_loc.nil? == other.then_keyword_loc.nil?) &&
+        (statements === other.statements) &&
+        (consequent === other.consequent) &&
+        (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
+    end
   end
 
   # Represents the use of the `until` keyword, either in the block form or the modifier form.
@@ -18153,9 +19611,9 @@ module Prism
       { flags: flags, keyword_loc: keyword_loc, closing_loc: closing_loc, predicate: predicate, statements: statements, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader keyword_loc: Location
     def keyword_loc
@@ -18183,7 +19641,6 @@ module Prism
     # attr_reader statements: StatementsNode?
     attr_reader :statements
 
-
     # def begin_modifier?: () -> bool
     def begin_modifier?
       flags.anybits?(LoopFlags::BEGIN_MODIFIER)
@@ -18244,6 +19701,17 @@ module Prism
     def self.type
       :until_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(UntilNode) &&
+        (flags === other.flags) &&
+        (keyword_loc.nil? == other.keyword_loc.nil?) &&
+        (closing_loc.nil? == other.closing_loc.nil?) &&
+        (predicate === other.predicate) &&
+        (statements === other.statements)
+    end
   end
 
   # Represents the use of the `when` keyword within a case statement.
@@ -18326,7 +19794,6 @@ module Prism
     # attr_reader statements: StatementsNode?
     attr_reader :statements
 
-
     # def keyword: () -> String
     def keyword
       keyword_loc.slice
@@ -18379,6 +19846,17 @@ module Prism
     def self.type
       :when_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(WhenNode) &&
+        (keyword_loc.nil? == other.keyword_loc.nil?) &&
+        (conditions.length == other.conditions.length) &&
+        conditions.zip(other.conditions).all? { |left, right| left === right } &&
+        (then_keyword_loc.nil? == other.then_keyword_loc.nil?) &&
+        (statements === other.statements)
+    end
   end
 
   # Represents the use of the `while` keyword, either in the block form or the modifier form.
@@ -18441,9 +19919,9 @@ module Prism
       { flags: flags, keyword_loc: keyword_loc, closing_loc: closing_loc, predicate: predicate, statements: statements, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader keyword_loc: Location
     def keyword_loc
@@ -18471,7 +19949,6 @@ module Prism
     # attr_reader statements: StatementsNode?
     attr_reader :statements
 
-
     # def begin_modifier?: () -> bool
     def begin_modifier?
       flags.anybits?(LoopFlags::BEGIN_MODIFIER)
@@ -18532,6 +20009,17 @@ module Prism
     def self.type
       :while_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(WhileNode) &&
+        (flags === other.flags) &&
+        (keyword_loc.nil? == other.keyword_loc.nil?) &&
+        (closing_loc.nil? == other.closing_loc.nil?) &&
+        (predicate === other.predicate) &&
+        (statements === other.statements)
+    end
   end
 
   # Represents an xstring literal with no interpolation.
@@ -18584,9 +20072,9 @@ module Prism
       { flags: flags, opening_loc: opening_loc, content_loc: content_loc, closing_loc: closing_loc, unescaped: unescaped, location: location }
     end
 
-    # private attr_reader flags: Integer
+    # protected attr_reader flags: Integer
     attr_reader :flags
-    private :flags
+    protected :flags
 
     # attr_reader opening_loc: Location
     def opening_loc
@@ -18612,7 +20100,6 @@ module Prism
     # attr_reader unescaped: String
     attr_reader :unescaped
 
-
     # def forced_utf8_encoding?: () -> bool
     def forced_utf8_encoding?
       flags.anybits?(EncodingFlags::FORCED_UTF8_ENCODING)
@@ -18677,6 +20164,17 @@ module Prism
     def self.type
       :x_string_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(XStringNode) &&
+        (flags === other.flags) &&
+        (opening_loc.nil? == other.opening_loc.nil?) &&
+        (content_loc.nil? == other.content_loc.nil?) &&
+        (closing_loc.nil? == other.closing_loc.nil?) &&
+        (unescaped === other.unescaped)
+    end
   end
 
   # Represents the use of the `yield` keyword.
@@ -18766,7 +20264,6 @@ module Prism
       end
     end
 
-
     # def keyword: () -> String
     def keyword
       keyword_loc.slice
@@ -18824,6 +20321,16 @@ module Prism
     def self.type
       :yield_node
     end
+
+    # Implements case-equality for the node. This is effectively == but without
+    # comparing the value of locations. Locations are checked only for presence.
+    def ===(other)
+      other.is_a?(YieldNode) &&
+        (keyword_loc.nil? == other.keyword_loc.nil?) &&
+        (lparen_loc.nil? == other.lparen_loc.nil?) &&
+        (arguments === other.arguments) &&
+        (rparen_loc.nil? == other.rparen_loc.nil?)
+    end
   end
 
   # Flags for arguments nodes.