prism 0.26.0 → 0.27.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
data/lib/prism/node.rb CHANGED
@@ -176,20 +176,28 @@ module Prism
176
176
  { new_name: new_name, old_name: old_name, keyword_loc: keyword_loc, location: location }
177
177
  end
178
178
 
179
- # attr_reader new_name: Prism::node
179
+ # 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.
180
+ #
181
+ # alias $foo $bar
182
+ # ^^^^
180
183
  attr_reader :new_name
181
184
 
182
- # attr_reader old_name: Prism::node
185
+ # 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.
186
+ #
187
+ # alias $foo $bar
188
+ # ^^^^
183
189
  attr_reader :old_name
184
190
 
185
- # attr_reader keyword_loc: Location
191
+ # The location of the `alias` keyword.
192
+ #
193
+ # alias $foo $bar
194
+ # ^^^^^
186
195
  def keyword_loc
187
196
  location = @keyword_loc
188
197
  return location if location.is_a?(Location)
189
198
  @keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
190
199
  end
191
200
 
192
-
193
201
  # def keyword: () -> String
194
202
  def keyword
195
203
  keyword_loc.slice
@@ -233,6 +241,15 @@ module Prism
233
241
  def self.type
234
242
  :alias_global_variable_node
235
243
  end
244
+
245
+ # Implements case-equality for the node. This is effectively == but without
246
+ # comparing the value of locations. Locations are checked only for presence.
247
+ def ===(other)
248
+ other.is_a?(AliasGlobalVariableNode) &&
249
+ (new_name === other.new_name) &&
250
+ (old_name === other.old_name) &&
251
+ (keyword_loc.nil? == other.keyword_loc.nil?)
252
+ end
236
253
  end
237
254
 
238
255
  # Represents the use of the `alias` keyword to alias a method.
@@ -296,7 +313,6 @@ module Prism
296
313
  @keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
297
314
  end
298
315
 
299
-
300
316
  # def keyword: () -> String
301
317
  def keyword
302
318
  keyword_loc.slice
@@ -340,6 +356,15 @@ module Prism
340
356
  def self.type
341
357
  :alias_method_node
342
358
  end
359
+
360
+ # Implements case-equality for the node. This is effectively == but without
361
+ # comparing the value of locations. Locations are checked only for presence.
362
+ def ===(other)
363
+ other.is_a?(AliasMethodNode) &&
364
+ (new_name === other.new_name) &&
365
+ (old_name === other.old_name) &&
366
+ (keyword_loc.nil? == other.keyword_loc.nil?)
367
+ end
343
368
  end
344
369
 
345
370
  # Represents an alternation pattern in pattern matching.
@@ -403,7 +428,6 @@ module Prism
403
428
  @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
404
429
  end
405
430
 
406
-
407
431
  # def operator: () -> String
408
432
  def operator
409
433
  operator_loc.slice
@@ -447,6 +471,15 @@ module Prism
447
471
  def self.type
448
472
  :alternation_pattern_node
449
473
  end
474
+
475
+ # Implements case-equality for the node. This is effectively == but without
476
+ # comparing the value of locations. Locations are checked only for presence.
477
+ def ===(other)
478
+ other.is_a?(AlternationPatternNode) &&
479
+ (left === other.left) &&
480
+ (right === other.right) &&
481
+ (operator_loc.nil? == other.operator_loc.nil?)
482
+ end
450
483
  end
451
484
 
452
485
  # Represents the use of the `&&` operator or the `and` keyword.
@@ -525,7 +558,6 @@ module Prism
525
558
  @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
526
559
  end
527
560
 
528
-
529
561
  # def operator: () -> String
530
562
  def operator
531
563
  operator_loc.slice
@@ -569,6 +601,15 @@ module Prism
569
601
  def self.type
570
602
  :and_node
571
603
  end
604
+
605
+ # Implements case-equality for the node. This is effectively == but without
606
+ # comparing the value of locations. Locations are checked only for presence.
607
+ def ===(other)
608
+ other.is_a?(AndNode) &&
609
+ (left === other.left) &&
610
+ (right === other.right) &&
611
+ (operator_loc.nil? == other.operator_loc.nil?)
612
+ end
572
613
  end
573
614
 
574
615
  # Represents a set of arguments to a method or a keyword.
@@ -618,14 +659,13 @@ module Prism
618
659
  { flags: flags, arguments: arguments, location: location }
619
660
  end
620
661
 
621
- # private attr_reader flags: Integer
662
+ # protected attr_reader flags: Integer
622
663
  attr_reader :flags
623
- private :flags
664
+ protected :flags
624
665
 
625
666
  # attr_reader arguments: Array[Prism::node]
626
667
  attr_reader :arguments
627
668
 
628
-
629
669
  # def contains_keyword_splat?: () -> bool
630
670
  def contains_keyword_splat?
631
671
  flags.anybits?(ArgumentsNodeFlags::CONTAINS_KEYWORD_SPLAT)
@@ -667,6 +707,15 @@ module Prism
667
707
  def self.type
668
708
  :arguments_node
669
709
  end
710
+
711
+ # Implements case-equality for the node. This is effectively == but without
712
+ # comparing the value of locations. Locations are checked only for presence.
713
+ def ===(other)
714
+ other.is_a?(ArgumentsNode) &&
715
+ (flags === other.flags) &&
716
+ (arguments.length == other.arguments.length) &&
717
+ arguments.zip(other.arguments).all? { |left, right| left === right }
718
+ end
670
719
  end
671
720
 
672
721
  # 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
718
767
  { flags: flags, elements: elements, opening_loc: opening_loc, closing_loc: closing_loc, location: location }
719
768
  end
720
769
 
721
- # private attr_reader flags: Integer
770
+ # protected attr_reader flags: Integer
722
771
  attr_reader :flags
723
- private :flags
772
+ protected :flags
724
773
 
725
- # attr_reader elements: Array[Prism::node]
774
+ # 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.
726
775
  attr_reader :elements
727
776
 
728
- # attr_reader opening_loc: Location?
777
+ # Represents the optional source location for the opening token.
778
+ #
779
+ # [1,2,3] # "["
780
+ # %w[foo bar baz] # "%w["
781
+ # %I(apple orange banana) # "%I("
782
+ # foo = 1, 2, 3 # nil
729
783
  def opening_loc
730
784
  location = @opening_loc
731
785
  case location
@@ -738,7 +792,12 @@ module Prism
738
792
  end
739
793
  end
740
794
 
741
- # attr_reader closing_loc: Location?
795
+ # Represents the optional source location for the closing token.
796
+ #
797
+ # [1,2,3] # "]"
798
+ # %w[foo bar baz] # "]"
799
+ # %I(apple orange banana) # ")"
800
+ # foo = 1, 2, 3 # nil
742
801
  def closing_loc
743
802
  location = @closing_loc
744
803
  case location
@@ -751,7 +810,6 @@ module Prism
751
810
  end
752
811
  end
753
812
 
754
-
755
813
  # def contains_splat?: () -> bool
756
814
  def contains_splat?
757
815
  flags.anybits?(ArrayNodeFlags::CONTAINS_SPLAT)
@@ -805,6 +863,17 @@ module Prism
805
863
  def self.type
806
864
  :array_node
807
865
  end
866
+
867
+ # Implements case-equality for the node. This is effectively == but without
868
+ # comparing the value of locations. Locations are checked only for presence.
869
+ def ===(other)
870
+ other.is_a?(ArrayNode) &&
871
+ (flags === other.flags) &&
872
+ (elements.length == other.elements.length) &&
873
+ elements.zip(other.elements).all? { |left, right| left === right } &&
874
+ (opening_loc.nil? == other.opening_loc.nil?) &&
875
+ (closing_loc.nil? == other.closing_loc.nil?)
876
+ end
808
877
  end
809
878
 
810
879
  # Represents an array pattern in pattern matching.
@@ -913,7 +982,6 @@ module Prism
913
982
  end
914
983
  end
915
984
 
916
-
917
985
  # def opening: () -> String?
918
986
  def opening
919
987
  opening_loc&.slice
@@ -973,6 +1041,20 @@ module Prism
973
1041
  def self.type
974
1042
  :array_pattern_node
975
1043
  end
1044
+
1045
+ # Implements case-equality for the node. This is effectively == but without
1046
+ # comparing the value of locations. Locations are checked only for presence.
1047
+ def ===(other)
1048
+ other.is_a?(ArrayPatternNode) &&
1049
+ (constant === other.constant) &&
1050
+ (requireds.length == other.requireds.length) &&
1051
+ requireds.zip(other.requireds).all? { |left, right| left === right } &&
1052
+ (rest === other.rest) &&
1053
+ (posts.length == other.posts.length) &&
1054
+ posts.zip(other.posts).all? { |left, right| left === right } &&
1055
+ (opening_loc.nil? == other.opening_loc.nil?) &&
1056
+ (closing_loc.nil? == other.closing_loc.nil?)
1057
+ end
976
1058
  end
977
1059
 
978
1060
  # Represents a hash key/value pair.
@@ -1060,7 +1142,6 @@ module Prism
1060
1142
  end
1061
1143
  end
1062
1144
 
1063
-
1064
1145
  # def operator: () -> String?
1065
1146
  def operator
1066
1147
  operator_loc&.slice
@@ -1104,6 +1185,15 @@ module Prism
1104
1185
  def self.type
1105
1186
  :assoc_node
1106
1187
  end
1188
+
1189
+ # Implements case-equality for the node. This is effectively == but without
1190
+ # comparing the value of locations. Locations are checked only for presence.
1191
+ def ===(other)
1192
+ other.is_a?(AssocNode) &&
1193
+ (key === other.key) &&
1194
+ (value === other.value) &&
1195
+ (operator_loc.nil? == other.operator_loc.nil?)
1196
+ end
1107
1197
  end
1108
1198
 
1109
1199
  # Represents a splat in a hash literal.
@@ -1171,7 +1261,6 @@ module Prism
1171
1261
  @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
1172
1262
  end
1173
1263
 
1174
-
1175
1264
  # def operator: () -> String
1176
1265
  def operator
1177
1266
  operator_loc.slice
@@ -1217,6 +1306,14 @@ module Prism
1217
1306
  def self.type
1218
1307
  :assoc_splat_node
1219
1308
  end
1309
+
1310
+ # Implements case-equality for the node. This is effectively == but without
1311
+ # comparing the value of locations. Locations are checked only for presence.
1312
+ def ===(other)
1313
+ other.is_a?(AssocSplatNode) &&
1314
+ (value === other.value) &&
1315
+ (operator_loc.nil? == other.operator_loc.nil?)
1316
+ end
1220
1317
  end
1221
1318
 
1222
1319
  # Represents reading a reference to a field in the previous match.
@@ -1272,7 +1369,6 @@ module Prism
1272
1369
  # $+ # name `:$+`
1273
1370
  attr_reader :name
1274
1371
 
1275
-
1276
1372
  # def inspect(NodeInspector inspector) -> String
1277
1373
  def inspect(inspector = NodeInspector.new)
1278
1374
  inspector << inspector.header(self)
@@ -1307,6 +1403,13 @@ module Prism
1307
1403
  def self.type
1308
1404
  :back_reference_read_node
1309
1405
  end
1406
+
1407
+ # Implements case-equality for the node. This is effectively == but without
1408
+ # comparing the value of locations. Locations are checked only for presence.
1409
+ def ===(other)
1410
+ other.is_a?(BackReferenceReadNode) &&
1411
+ (name === other.name)
1412
+ end
1310
1413
  end
1311
1414
 
1312
1415
  # Represents a begin statement.
@@ -1409,7 +1512,6 @@ module Prism
1409
1512
  end
1410
1513
  end
1411
1514
 
1412
-
1413
1515
  # def begin_keyword: () -> String?
1414
1516
  def begin_keyword
1415
1517
  begin_keyword_loc&.slice
@@ -1479,6 +1581,18 @@ module Prism
1479
1581
  def self.type
1480
1582
  :begin_node
1481
1583
  end
1584
+
1585
+ # Implements case-equality for the node. This is effectively == but without
1586
+ # comparing the value of locations. Locations are checked only for presence.
1587
+ def ===(other)
1588
+ other.is_a?(BeginNode) &&
1589
+ (begin_keyword_loc.nil? == other.begin_keyword_loc.nil?) &&
1590
+ (statements === other.statements) &&
1591
+ (rescue_clause === other.rescue_clause) &&
1592
+ (else_clause === other.else_clause) &&
1593
+ (ensure_clause === other.ensure_clause) &&
1594
+ (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
1595
+ end
1482
1596
  end
1483
1597
 
1484
1598
  # Represents block method arguments.
@@ -1540,7 +1654,6 @@ module Prism
1540
1654
  @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
1541
1655
  end
1542
1656
 
1543
-
1544
1657
  # def operator: () -> String
1545
1658
  def operator
1546
1659
  operator_loc.slice
@@ -1586,6 +1699,14 @@ module Prism
1586
1699
  def self.type
1587
1700
  :block_argument_node
1588
1701
  end
1702
+
1703
+ # Implements case-equality for the node. This is effectively == but without
1704
+ # comparing the value of locations. Locations are checked only for presence.
1705
+ def ===(other)
1706
+ other.is_a?(BlockArgumentNode) &&
1707
+ (expression === other.expression) &&
1708
+ (operator_loc.nil? == other.operator_loc.nil?)
1709
+ end
1589
1710
  end
1590
1711
 
1591
1712
  # Represents a block local variable.
@@ -1635,14 +1756,13 @@ module Prism
1635
1756
  { flags: flags, name: name, location: location }
1636
1757
  end
1637
1758
 
1638
- # private attr_reader flags: Integer
1759
+ # protected attr_reader flags: Integer
1639
1760
  attr_reader :flags
1640
- private :flags
1761
+ protected :flags
1641
1762
 
1642
1763
  # attr_reader name: Symbol
1643
1764
  attr_reader :name
1644
1765
 
1645
-
1646
1766
  # def repeated_parameter?: () -> bool
1647
1767
  def repeated_parameter?
1648
1768
  flags.anybits?(ParameterFlags::REPEATED_PARAMETER)
@@ -1684,6 +1804,14 @@ module Prism
1684
1804
  def self.type
1685
1805
  :block_local_variable_node
1686
1806
  end
1807
+
1808
+ # Implements case-equality for the node. This is effectively == but without
1809
+ # comparing the value of locations. Locations are checked only for presence.
1810
+ def ===(other)
1811
+ other.is_a?(BlockLocalVariableNode) &&
1812
+ (flags === other.flags) &&
1813
+ (name === other.name)
1814
+ end
1687
1815
  end
1688
1816
 
1689
1817
  # Represents a block of ruby code.
@@ -1762,7 +1890,6 @@ module Prism
1762
1890
  @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
1763
1891
  end
1764
1892
 
1765
-
1766
1893
  # def opening: () -> String
1767
1894
  def opening
1768
1895
  opening_loc.slice
@@ -1821,6 +1948,18 @@ module Prism
1821
1948
  def self.type
1822
1949
  :block_node
1823
1950
  end
1951
+
1952
+ # Implements case-equality for the node. This is effectively == but without
1953
+ # comparing the value of locations. Locations are checked only for presence.
1954
+ def ===(other)
1955
+ other.is_a?(BlockNode) &&
1956
+ (locals.length == other.locals.length) &&
1957
+ locals.zip(other.locals).all? { |left, right| left === right } &&
1958
+ (parameters === other.parameters) &&
1959
+ (body === other.body) &&
1960
+ (opening_loc.nil? == other.opening_loc.nil?) &&
1961
+ (closing_loc.nil? == other.closing_loc.nil?)
1962
+ end
1824
1963
  end
1825
1964
 
1826
1965
  # Represents a block parameter to a method, block, or lambda definition.
@@ -1873,9 +2012,9 @@ module Prism
1873
2012
  { flags: flags, name: name, name_loc: name_loc, operator_loc: operator_loc, location: location }
1874
2013
  end
1875
2014
 
1876
- # private attr_reader flags: Integer
2015
+ # protected attr_reader flags: Integer
1877
2016
  attr_reader :flags
1878
- private :flags
2017
+ protected :flags
1879
2018
 
1880
2019
  # attr_reader name: Symbol?
1881
2020
  attr_reader :name
@@ -1900,7 +2039,6 @@ module Prism
1900
2039
  @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
1901
2040
  end
1902
2041
 
1903
-
1904
2042
  # def repeated_parameter?: () -> bool
1905
2043
  def repeated_parameter?
1906
2044
  flags.anybits?(ParameterFlags::REPEATED_PARAMETER)
@@ -1953,6 +2091,16 @@ module Prism
1953
2091
  def self.type
1954
2092
  :block_parameter_node
1955
2093
  end
2094
+
2095
+ # Implements case-equality for the node. This is effectively == but without
2096
+ # comparing the value of locations. Locations are checked only for presence.
2097
+ def ===(other)
2098
+ other.is_a?(BlockParameterNode) &&
2099
+ (flags === other.flags) &&
2100
+ (name === other.name) &&
2101
+ (name_loc.nil? == other.name_loc.nil?) &&
2102
+ (operator_loc.nil? == other.operator_loc.nil?)
2103
+ end
1956
2104
  end
1957
2105
 
1958
2106
  # Represents a block's parameters declaration.
@@ -2043,7 +2191,6 @@ module Prism
2043
2191
  end
2044
2192
  end
2045
2193
 
2046
-
2047
2194
  # def opening: () -> String?
2048
2195
  def opening
2049
2196
  opening_loc&.slice
@@ -2096,6 +2243,17 @@ module Prism
2096
2243
  def self.type
2097
2244
  :block_parameters_node
2098
2245
  end
2246
+
2247
+ # Implements case-equality for the node. This is effectively == but without
2248
+ # comparing the value of locations. Locations are checked only for presence.
2249
+ def ===(other)
2250
+ other.is_a?(BlockParametersNode) &&
2251
+ (parameters === other.parameters) &&
2252
+ (locals.length == other.locals.length) &&
2253
+ locals.zip(other.locals).all? { |left, right| left === right } &&
2254
+ (opening_loc.nil? == other.opening_loc.nil?) &&
2255
+ (closing_loc.nil? == other.closing_loc.nil?)
2256
+ end
2099
2257
  end
2100
2258
 
2101
2259
  # Represents the use of the `break` keyword.
@@ -2147,17 +2305,22 @@ module Prism
2147
2305
  { arguments: arguments, keyword_loc: keyword_loc, location: location }
2148
2306
  end
2149
2307
 
2150
- # attr_reader arguments: ArgumentsNode?
2308
+ # 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).
2309
+ #
2310
+ # break foo
2311
+ # ^^^
2151
2312
  attr_reader :arguments
2152
2313
 
2153
- # attr_reader keyword_loc: Location
2314
+ # The location of the `break` keyword.
2315
+ #
2316
+ # break foo
2317
+ # ^^^^^
2154
2318
  def keyword_loc
2155
2319
  location = @keyword_loc
2156
2320
  return location if location.is_a?(Location)
2157
2321
  @keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
2158
2322
  end
2159
2323
 
2160
-
2161
2324
  # def keyword: () -> String
2162
2325
  def keyword
2163
2326
  keyword_loc.slice
@@ -2203,6 +2366,14 @@ module Prism
2203
2366
  def self.type
2204
2367
  :break_node
2205
2368
  end
2369
+
2370
+ # Implements case-equality for the node. This is effectively == but without
2371
+ # comparing the value of locations. Locations are checked only for presence.
2372
+ def ===(other)
2373
+ other.is_a?(BreakNode) &&
2374
+ (arguments === other.arguments) &&
2375
+ (keyword_loc.nil? == other.keyword_loc.nil?)
2376
+ end
2206
2377
  end
2207
2378
 
2208
2379
  # Represents the use of the `&&=` operator on a call.
@@ -2261,9 +2432,9 @@ module Prism
2261
2432
  { 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 }
2262
2433
  end
2263
2434
 
2264
- # private attr_reader flags: Integer
2435
+ # protected attr_reader flags: Integer
2265
2436
  attr_reader :flags
2266
- private :flags
2437
+ protected :flags
2267
2438
 
2268
2439
  # attr_reader receiver: Prism::node?
2269
2440
  attr_reader :receiver
@@ -2310,7 +2481,6 @@ module Prism
2310
2481
  # attr_reader value: Prism::node
2311
2482
  attr_reader :value
2312
2483
 
2313
-
2314
2484
  # def safe_navigation?: () -> bool
2315
2485
  def safe_navigation?
2316
2486
  flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -2394,6 +2564,20 @@ module Prism
2394
2564
  def self.type
2395
2565
  :call_and_write_node
2396
2566
  end
2567
+
2568
+ # Implements case-equality for the node. This is effectively == but without
2569
+ # comparing the value of locations. Locations are checked only for presence.
2570
+ def ===(other)
2571
+ other.is_a?(CallAndWriteNode) &&
2572
+ (flags === other.flags) &&
2573
+ (receiver === other.receiver) &&
2574
+ (call_operator_loc.nil? == other.call_operator_loc.nil?) &&
2575
+ (message_loc.nil? == other.message_loc.nil?) &&
2576
+ (read_name === other.read_name) &&
2577
+ (write_name === other.write_name) &&
2578
+ (operator_loc.nil? == other.operator_loc.nil?) &&
2579
+ (value === other.value)
2580
+ end
2397
2581
  end
2398
2582
 
2399
2583
  # Represents a method call, in all of the various forms that can take.
@@ -2469,9 +2653,9 @@ module Prism
2469
2653
  { 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 }
2470
2654
  end
2471
2655
 
2472
- # private attr_reader flags: Integer
2656
+ # protected attr_reader flags: Integer
2473
2657
  attr_reader :flags
2474
- private :flags
2658
+ protected :flags
2475
2659
 
2476
2660
  # 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).
2477
2661
  #
@@ -2546,7 +2730,6 @@ module Prism
2546
2730
  # attr_reader block: Prism::node?
2547
2731
  attr_reader :block
2548
2732
 
2549
-
2550
2733
  # def safe_navigation?: () -> bool
2551
2734
  def safe_navigation?
2552
2735
  flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -2645,6 +2828,21 @@ module Prism
2645
2828
  def self.type
2646
2829
  :call_node
2647
2830
  end
2831
+
2832
+ # Implements case-equality for the node. This is effectively == but without
2833
+ # comparing the value of locations. Locations are checked only for presence.
2834
+ def ===(other)
2835
+ other.is_a?(CallNode) &&
2836
+ (flags === other.flags) &&
2837
+ (receiver === other.receiver) &&
2838
+ (call_operator_loc.nil? == other.call_operator_loc.nil?) &&
2839
+ (name === other.name) &&
2840
+ (message_loc.nil? == other.message_loc.nil?) &&
2841
+ (opening_loc.nil? == other.opening_loc.nil?) &&
2842
+ (arguments === other.arguments) &&
2843
+ (closing_loc.nil? == other.closing_loc.nil?) &&
2844
+ (block === other.block)
2845
+ end
2648
2846
  end
2649
2847
 
2650
2848
  # Represents the use of an assignment operator on a call.
@@ -2704,9 +2902,9 @@ module Prism
2704
2902
  { 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 }
2705
2903
  end
2706
2904
 
2707
- # private attr_reader flags: Integer
2905
+ # protected attr_reader flags: Integer
2708
2906
  attr_reader :flags
2709
- private :flags
2907
+ protected :flags
2710
2908
 
2711
2909
  # attr_reader receiver: Prism::node?
2712
2910
  attr_reader :receiver
@@ -2756,7 +2954,6 @@ module Prism
2756
2954
  # attr_reader value: Prism::node
2757
2955
  attr_reader :value
2758
2956
 
2759
-
2760
2957
  # def safe_navigation?: () -> bool
2761
2958
  def safe_navigation?
2762
2959
  flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -2836,6 +3033,21 @@ module Prism
2836
3033
  def self.type
2837
3034
  :call_operator_write_node
2838
3035
  end
3036
+
3037
+ # Implements case-equality for the node. This is effectively == but without
3038
+ # comparing the value of locations. Locations are checked only for presence.
3039
+ def ===(other)
3040
+ other.is_a?(CallOperatorWriteNode) &&
3041
+ (flags === other.flags) &&
3042
+ (receiver === other.receiver) &&
3043
+ (call_operator_loc.nil? == other.call_operator_loc.nil?) &&
3044
+ (message_loc.nil? == other.message_loc.nil?) &&
3045
+ (read_name === other.read_name) &&
3046
+ (write_name === other.write_name) &&
3047
+ (operator === other.operator) &&
3048
+ (operator_loc.nil? == other.operator_loc.nil?) &&
3049
+ (value === other.value)
3050
+ end
2839
3051
  end
2840
3052
 
2841
3053
  # Represents the use of the `||=` operator on a call.
@@ -2894,9 +3106,9 @@ module Prism
2894
3106
  { 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 }
2895
3107
  end
2896
3108
 
2897
- # private attr_reader flags: Integer
3109
+ # protected attr_reader flags: Integer
2898
3110
  attr_reader :flags
2899
- private :flags
3111
+ protected :flags
2900
3112
 
2901
3113
  # attr_reader receiver: Prism::node?
2902
3114
  attr_reader :receiver
@@ -2943,7 +3155,6 @@ module Prism
2943
3155
  # attr_reader value: Prism::node
2944
3156
  attr_reader :value
2945
3157
 
2946
-
2947
3158
  # def safe_navigation?: () -> bool
2948
3159
  def safe_navigation?
2949
3160
  flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -3027,6 +3238,20 @@ module Prism
3027
3238
  def self.type
3028
3239
  :call_or_write_node
3029
3240
  end
3241
+
3242
+ # Implements case-equality for the node. This is effectively == but without
3243
+ # comparing the value of locations. Locations are checked only for presence.
3244
+ def ===(other)
3245
+ other.is_a?(CallOrWriteNode) &&
3246
+ (flags === other.flags) &&
3247
+ (receiver === other.receiver) &&
3248
+ (call_operator_loc.nil? == other.call_operator_loc.nil?) &&
3249
+ (message_loc.nil? == other.message_loc.nil?) &&
3250
+ (read_name === other.read_name) &&
3251
+ (write_name === other.write_name) &&
3252
+ (operator_loc.nil? == other.operator_loc.nil?) &&
3253
+ (value === other.value)
3254
+ end
3030
3255
  end
3031
3256
 
3032
3257
  # Represents assigning to a method call.
@@ -3087,9 +3312,9 @@ module Prism
3087
3312
  { flags: flags, receiver: receiver, call_operator_loc: call_operator_loc, name: name, message_loc: message_loc, location: location }
3088
3313
  end
3089
3314
 
3090
- # private attr_reader flags: Integer
3315
+ # protected attr_reader flags: Integer
3091
3316
  attr_reader :flags
3092
- private :flags
3317
+ protected :flags
3093
3318
 
3094
3319
  # attr_reader receiver: Prism::node
3095
3320
  attr_reader :receiver
@@ -3111,7 +3336,6 @@ module Prism
3111
3336
  @message_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
3112
3337
  end
3113
3338
 
3114
-
3115
3339
  # def safe_navigation?: () -> bool
3116
3340
  def safe_navigation?
3117
3341
  flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -3182,6 +3406,17 @@ module Prism
3182
3406
  def self.type
3183
3407
  :call_target_node
3184
3408
  end
3409
+
3410
+ # Implements case-equality for the node. This is effectively == but without
3411
+ # comparing the value of locations. Locations are checked only for presence.
3412
+ def ===(other)
3413
+ other.is_a?(CallTargetNode) &&
3414
+ (flags === other.flags) &&
3415
+ (receiver === other.receiver) &&
3416
+ (call_operator_loc.nil? == other.call_operator_loc.nil?) &&
3417
+ (name === other.name) &&
3418
+ (message_loc.nil? == other.message_loc.nil?)
3419
+ end
3185
3420
  end
3186
3421
 
3187
3422
  # Represents assigning to a local variable in pattern matching.
@@ -3245,7 +3480,6 @@ module Prism
3245
3480
  @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
3246
3481
  end
3247
3482
 
3248
-
3249
3483
  # def operator: () -> String
3250
3484
  def operator
3251
3485
  operator_loc.slice
@@ -3289,6 +3523,15 @@ module Prism
3289
3523
  def self.type
3290
3524
  :capture_pattern_node
3291
3525
  end
3526
+
3527
+ # Implements case-equality for the node. This is effectively == but without
3528
+ # comparing the value of locations. Locations are checked only for presence.
3529
+ def ===(other)
3530
+ other.is_a?(CapturePatternNode) &&
3531
+ (value === other.value) &&
3532
+ (target === other.target) &&
3533
+ (operator_loc.nil? == other.operator_loc.nil?)
3534
+ end
3292
3535
  end
3293
3536
 
3294
3537
  # Represents the use of a case statement for pattern matching.
@@ -3370,7 +3613,6 @@ module Prism
3370
3613
  @end_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
3371
3614
  end
3372
3615
 
3373
-
3374
3616
  # def case_keyword: () -> String
3375
3617
  def case_keyword
3376
3618
  case_keyword_loc.slice
@@ -3429,6 +3671,18 @@ module Prism
3429
3671
  def self.type
3430
3672
  :case_match_node
3431
3673
  end
3674
+
3675
+ # Implements case-equality for the node. This is effectively == but without
3676
+ # comparing the value of locations. Locations are checked only for presence.
3677
+ def ===(other)
3678
+ other.is_a?(CaseMatchNode) &&
3679
+ (predicate === other.predicate) &&
3680
+ (conditions.length == other.conditions.length) &&
3681
+ conditions.zip(other.conditions).all? { |left, right| left === right } &&
3682
+ (consequent === other.consequent) &&
3683
+ (case_keyword_loc.nil? == other.case_keyword_loc.nil?) &&
3684
+ (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
3685
+ end
3432
3686
  end
3433
3687
 
3434
3688
  # Represents the use of a case statement.
@@ -3510,7 +3764,6 @@ module Prism
3510
3764
  @end_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
3511
3765
  end
3512
3766
 
3513
-
3514
3767
  # def case_keyword: () -> String
3515
3768
  def case_keyword
3516
3769
  case_keyword_loc.slice
@@ -3569,6 +3822,18 @@ module Prism
3569
3822
  def self.type
3570
3823
  :case_node
3571
3824
  end
3825
+
3826
+ # Implements case-equality for the node. This is effectively == but without
3827
+ # comparing the value of locations. Locations are checked only for presence.
3828
+ def ===(other)
3829
+ other.is_a?(CaseNode) &&
3830
+ (predicate === other.predicate) &&
3831
+ (conditions.length == other.conditions.length) &&
3832
+ conditions.zip(other.conditions).all? { |left, right| left === right } &&
3833
+ (consequent === other.consequent) &&
3834
+ (case_keyword_loc.nil? == other.case_keyword_loc.nil?) &&
3835
+ (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
3836
+ end
3572
3837
  end
3573
3838
 
3574
3839
  # Represents a class declaration involving the `class` keyword.
@@ -3670,7 +3935,6 @@ module Prism
3670
3935
  # attr_reader name: Symbol
3671
3936
  attr_reader :name
3672
3937
 
3673
-
3674
3938
  # def class_keyword: () -> String
3675
3939
  def class_keyword
3676
3940
  class_keyword_loc.slice
@@ -3738,6 +4002,21 @@ module Prism
3738
4002
  def self.type
3739
4003
  :class_node
3740
4004
  end
4005
+
4006
+ # Implements case-equality for the node. This is effectively == but without
4007
+ # comparing the value of locations. Locations are checked only for presence.
4008
+ def ===(other)
4009
+ other.is_a?(ClassNode) &&
4010
+ (locals.length == other.locals.length) &&
4011
+ locals.zip(other.locals).all? { |left, right| left === right } &&
4012
+ (class_keyword_loc.nil? == other.class_keyword_loc.nil?) &&
4013
+ (constant_path === other.constant_path) &&
4014
+ (inheritance_operator_loc.nil? == other.inheritance_operator_loc.nil?) &&
4015
+ (superclass === other.superclass) &&
4016
+ (body === other.body) &&
4017
+ (end_keyword_loc.nil? == other.end_keyword_loc.nil?) &&
4018
+ (name === other.name)
4019
+ end
3741
4020
  end
3742
4021
 
3743
4022
  # Represents the use of the `&&=` operator for assignment to a class variable.
@@ -3809,7 +4088,6 @@ module Prism
3809
4088
  # attr_reader value: Prism::node
3810
4089
  attr_reader :value
3811
4090
 
3812
-
3813
4091
  # def operator: () -> String
3814
4092
  def operator
3815
4093
  operator_loc.slice
@@ -3853,6 +4131,16 @@ module Prism
3853
4131
  def self.type
3854
4132
  :class_variable_and_write_node
3855
4133
  end
4134
+
4135
+ # Implements case-equality for the node. This is effectively == but without
4136
+ # comparing the value of locations. Locations are checked only for presence.
4137
+ def ===(other)
4138
+ other.is_a?(ClassVariableAndWriteNode) &&
4139
+ (name === other.name) &&
4140
+ (name_loc.nil? == other.name_loc.nil?) &&
4141
+ (operator_loc.nil? == other.operator_loc.nil?) &&
4142
+ (value === other.value)
4143
+ end
3856
4144
  end
3857
4145
 
3858
4146
  # Represents assigning to a class variable using an operator that isn't `=`.
@@ -3928,7 +4216,6 @@ module Prism
3928
4216
  # attr_reader operator: Symbol
3929
4217
  attr_reader :operator
3930
4218
 
3931
-
3932
4219
  # def inspect(NodeInspector inspector) -> String
3933
4220
  def inspect(inspector = NodeInspector.new)
3934
4221
  inspector << inspector.header(self)
@@ -3968,6 +4255,17 @@ module Prism
3968
4255
  def self.type
3969
4256
  :class_variable_operator_write_node
3970
4257
  end
4258
+
4259
+ # Implements case-equality for the node. This is effectively == but without
4260
+ # comparing the value of locations. Locations are checked only for presence.
4261
+ def ===(other)
4262
+ other.is_a?(ClassVariableOperatorWriteNode) &&
4263
+ (name === other.name) &&
4264
+ (name_loc.nil? == other.name_loc.nil?) &&
4265
+ (operator_loc.nil? == other.operator_loc.nil?) &&
4266
+ (value === other.value) &&
4267
+ (operator === other.operator)
4268
+ end
3971
4269
  end
3972
4270
 
3973
4271
  # Represents the use of the `||=` operator for assignment to a class variable.
@@ -4039,7 +4337,6 @@ module Prism
4039
4337
  # attr_reader value: Prism::node
4040
4338
  attr_reader :value
4041
4339
 
4042
-
4043
4340
  # def operator: () -> String
4044
4341
  def operator
4045
4342
  operator_loc.slice
@@ -4083,6 +4380,16 @@ module Prism
4083
4380
  def self.type
4084
4381
  :class_variable_or_write_node
4085
4382
  end
4383
+
4384
+ # Implements case-equality for the node. This is effectively == but without
4385
+ # comparing the value of locations. Locations are checked only for presence.
4386
+ def ===(other)
4387
+ other.is_a?(ClassVariableOrWriteNode) &&
4388
+ (name === other.name) &&
4389
+ (name_loc.nil? == other.name_loc.nil?) &&
4390
+ (operator_loc.nil? == other.operator_loc.nil?) &&
4391
+ (value === other.value)
4392
+ end
4086
4393
  end
4087
4394
 
4088
4395
  # Represents referencing a class variable.
@@ -4138,7 +4445,6 @@ module Prism
4138
4445
  # @@_test # name `:@@_test`
4139
4446
  attr_reader :name
4140
4447
 
4141
-
4142
4448
  # def inspect(NodeInspector inspector) -> String
4143
4449
  def inspect(inspector = NodeInspector.new)
4144
4450
  inspector << inspector.header(self)
@@ -4173,6 +4479,13 @@ module Prism
4173
4479
  def self.type
4174
4480
  :class_variable_read_node
4175
4481
  end
4482
+
4483
+ # Implements case-equality for the node. This is effectively == but without
4484
+ # comparing the value of locations. Locations are checked only for presence.
4485
+ def ===(other)
4486
+ other.is_a?(ClassVariableReadNode) &&
4487
+ (name === other.name)
4488
+ end
4176
4489
  end
4177
4490
 
4178
4491
  # Represents writing to a class variable in a context that doesn't have an explicit value.
@@ -4224,7 +4537,6 @@ module Prism
4224
4537
  # attr_reader name: Symbol
4225
4538
  attr_reader :name
4226
4539
 
4227
-
4228
4540
  # def inspect(NodeInspector inspector) -> String
4229
4541
  def inspect(inspector = NodeInspector.new)
4230
4542
  inspector << inspector.header(self)
@@ -4259,6 +4571,13 @@ module Prism
4259
4571
  def self.type
4260
4572
  :class_variable_target_node
4261
4573
  end
4574
+
4575
+ # Implements case-equality for the node. This is effectively == but without
4576
+ # comparing the value of locations. Locations are checked only for presence.
4577
+ def ===(other)
4578
+ other.is_a?(ClassVariableTargetNode) &&
4579
+ (name === other.name)
4580
+ end
4262
4581
  end
4263
4582
 
4264
4583
  # Represents writing to a class variable.
@@ -4327,8 +4646,7 @@ module Prism
4327
4646
  @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
4328
4647
  end
4329
4648
 
4330
- # The value to assign to the class variable. Can be any node that
4331
- # represents a non-void expression.
4649
+ # 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).
4332
4650
  #
4333
4651
  # @@foo = :bar
4334
4652
  # ^^^^
@@ -4347,7 +4665,6 @@ module Prism
4347
4665
  @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
4348
4666
  end
4349
4667
 
4350
-
4351
4668
  # def operator: () -> String
4352
4669
  def operator
4353
4670
  operator_loc.slice
@@ -4391,6 +4708,16 @@ module Prism
4391
4708
  def self.type
4392
4709
  :class_variable_write_node
4393
4710
  end
4711
+
4712
+ # Implements case-equality for the node. This is effectively == but without
4713
+ # comparing the value of locations. Locations are checked only for presence.
4714
+ def ===(other)
4715
+ other.is_a?(ClassVariableWriteNode) &&
4716
+ (name === other.name) &&
4717
+ (name_loc.nil? == other.name_loc.nil?) &&
4718
+ (value === other.value) &&
4719
+ (operator_loc.nil? == other.operator_loc.nil?)
4720
+ end
4394
4721
  end
4395
4722
 
4396
4723
  # Represents the use of the `&&=` operator for assignment to a constant.
@@ -4462,7 +4789,6 @@ module Prism
4462
4789
  # attr_reader value: Prism::node
4463
4790
  attr_reader :value
4464
4791
 
4465
-
4466
4792
  # def operator: () -> String
4467
4793
  def operator
4468
4794
  operator_loc.slice
@@ -4506,6 +4832,16 @@ module Prism
4506
4832
  def self.type
4507
4833
  :constant_and_write_node
4508
4834
  end
4835
+
4836
+ # Implements case-equality for the node. This is effectively == but without
4837
+ # comparing the value of locations. Locations are checked only for presence.
4838
+ def ===(other)
4839
+ other.is_a?(ConstantAndWriteNode) &&
4840
+ (name === other.name) &&
4841
+ (name_loc.nil? == other.name_loc.nil?) &&
4842
+ (operator_loc.nil? == other.operator_loc.nil?) &&
4843
+ (value === other.value)
4844
+ end
4509
4845
  end
4510
4846
 
4511
4847
  # Represents assigning to a constant using an operator that isn't `=`.
@@ -4581,7 +4917,6 @@ module Prism
4581
4917
  # attr_reader operator: Symbol
4582
4918
  attr_reader :operator
4583
4919
 
4584
-
4585
4920
  # def inspect(NodeInspector inspector) -> String
4586
4921
  def inspect(inspector = NodeInspector.new)
4587
4922
  inspector << inspector.header(self)
@@ -4621,6 +4956,17 @@ module Prism
4621
4956
  def self.type
4622
4957
  :constant_operator_write_node
4623
4958
  end
4959
+
4960
+ # Implements case-equality for the node. This is effectively == but without
4961
+ # comparing the value of locations. Locations are checked only for presence.
4962
+ def ===(other)
4963
+ other.is_a?(ConstantOperatorWriteNode) &&
4964
+ (name === other.name) &&
4965
+ (name_loc.nil? == other.name_loc.nil?) &&
4966
+ (operator_loc.nil? == other.operator_loc.nil?) &&
4967
+ (value === other.value) &&
4968
+ (operator === other.operator)
4969
+ end
4624
4970
  end
4625
4971
 
4626
4972
  # Represents the use of the `||=` operator for assignment to a constant.
@@ -4692,7 +5038,6 @@ module Prism
4692
5038
  # attr_reader value: Prism::node
4693
5039
  attr_reader :value
4694
5040
 
4695
-
4696
5041
  # def operator: () -> String
4697
5042
  def operator
4698
5043
  operator_loc.slice
@@ -4736,6 +5081,16 @@ module Prism
4736
5081
  def self.type
4737
5082
  :constant_or_write_node
4738
5083
  end
5084
+
5085
+ # Implements case-equality for the node. This is effectively == but without
5086
+ # comparing the value of locations. Locations are checked only for presence.
5087
+ def ===(other)
5088
+ other.is_a?(ConstantOrWriteNode) &&
5089
+ (name === other.name) &&
5090
+ (name_loc.nil? == other.name_loc.nil?) &&
5091
+ (operator_loc.nil? == other.operator_loc.nil?) &&
5092
+ (value === other.value)
5093
+ end
4739
5094
  end
4740
5095
 
4741
5096
  # Represents the use of the `&&=` operator for assignment to a constant path.
@@ -4799,7 +5154,6 @@ module Prism
4799
5154
  # attr_reader value: Prism::node
4800
5155
  attr_reader :value
4801
5156
 
4802
-
4803
5157
  # def operator: () -> String
4804
5158
  def operator
4805
5159
  operator_loc.slice
@@ -4843,6 +5197,15 @@ module Prism
4843
5197
  def self.type
4844
5198
  :constant_path_and_write_node
4845
5199
  end
5200
+
5201
+ # Implements case-equality for the node. This is effectively == but without
5202
+ # comparing the value of locations. Locations are checked only for presence.
5203
+ def ===(other)
5204
+ other.is_a?(ConstantPathAndWriteNode) &&
5205
+ (target === other.target) &&
5206
+ (operator_loc.nil? == other.operator_loc.nil?) &&
5207
+ (value === other.value)
5208
+ end
4846
5209
  end
4847
5210
 
4848
5211
  # Represents accessing a constant through a path of `::` operators.
@@ -4896,20 +5259,44 @@ module Prism
4896
5259
  { parent: parent, child: child, delimiter_loc: delimiter_loc, location: location }
4897
5260
  end
4898
5261
 
4899
- # attr_reader parent: Prism::node?
5262
+ # 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.
5263
+ #
5264
+ # Foo::Bar
5265
+ # ^^^
5266
+ #
5267
+ # self::Test
5268
+ # ^^^^
5269
+ #
5270
+ # a.b::C
5271
+ # ^^^
4900
5272
  attr_reader :parent
4901
5273
 
4902
- # attr_reader child: ConstantReadNode | MissingNode
5274
+ # The right-hand node of the path. Always a `ConstantReadNode` in a
5275
+ # valid Ruby syntax tree.
5276
+ #
5277
+ # ::Foo
5278
+ # ^^^
5279
+ #
5280
+ # self::Test
5281
+ # ^^^^
5282
+ #
5283
+ # a.b::C
5284
+ # ^
4903
5285
  attr_reader :child
4904
5286
 
4905
- # attr_reader delimiter_loc: Location
5287
+ # The location of the `::` delimiter.
5288
+ #
5289
+ # ::Foo
5290
+ # ^^
5291
+ #
5292
+ # One::Two
5293
+ # ^^
4906
5294
  def delimiter_loc
4907
5295
  location = @delimiter_loc
4908
5296
  return location if location.is_a?(Location)
4909
5297
  @delimiter_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
4910
5298
  end
4911
5299
 
4912
-
4913
5300
  # def delimiter: () -> String
4914
5301
  def delimiter
4915
5302
  delimiter_loc.slice
@@ -4957,6 +5344,15 @@ module Prism
4957
5344
  def self.type
4958
5345
  :constant_path_node
4959
5346
  end
5347
+
5348
+ # Implements case-equality for the node. This is effectively == but without
5349
+ # comparing the value of locations. Locations are checked only for presence.
5350
+ def ===(other)
5351
+ other.is_a?(ConstantPathNode) &&
5352
+ (parent === other.parent) &&
5353
+ (child === other.child) &&
5354
+ (delimiter_loc.nil? == other.delimiter_loc.nil?)
5355
+ end
4960
5356
  end
4961
5357
 
4962
5358
  # Represents assigning to a constant path using an operator that isn't `=`.
@@ -5024,7 +5420,6 @@ module Prism
5024
5420
  # attr_reader operator: Symbol
5025
5421
  attr_reader :operator
5026
5422
 
5027
-
5028
5423
  # def inspect(NodeInspector inspector) -> String
5029
5424
  def inspect(inspector = NodeInspector.new)
5030
5425
  inspector << inspector.header(self)
@@ -5064,6 +5459,16 @@ module Prism
5064
5459
  def self.type
5065
5460
  :constant_path_operator_write_node
5066
5461
  end
5462
+
5463
+ # Implements case-equality for the node. This is effectively == but without
5464
+ # comparing the value of locations. Locations are checked only for presence.
5465
+ def ===(other)
5466
+ other.is_a?(ConstantPathOperatorWriteNode) &&
5467
+ (target === other.target) &&
5468
+ (operator_loc.nil? == other.operator_loc.nil?) &&
5469
+ (value === other.value) &&
5470
+ (operator === other.operator)
5471
+ end
5067
5472
  end
5068
5473
 
5069
5474
  # Represents the use of the `||=` operator for assignment to a constant path.
@@ -5127,7 +5532,6 @@ module Prism
5127
5532
  # attr_reader value: Prism::node
5128
5533
  attr_reader :value
5129
5534
 
5130
-
5131
5535
  # def operator: () -> String
5132
5536
  def operator
5133
5537
  operator_loc.slice
@@ -5171,6 +5575,15 @@ module Prism
5171
5575
  def self.type
5172
5576
  :constant_path_or_write_node
5173
5577
  end
5578
+
5579
+ # Implements case-equality for the node. This is effectively == but without
5580
+ # comparing the value of locations. Locations are checked only for presence.
5581
+ def ===(other)
5582
+ other.is_a?(ConstantPathOrWriteNode) &&
5583
+ (target === other.target) &&
5584
+ (operator_loc.nil? == other.operator_loc.nil?) &&
5585
+ (value === other.value)
5586
+ end
5174
5587
  end
5175
5588
 
5176
5589
  # Represents writing to a constant path in a context that doesn't have an explicit value.
@@ -5237,7 +5650,6 @@ module Prism
5237
5650
  @delimiter_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
5238
5651
  end
5239
5652
 
5240
-
5241
5653
  # def delimiter: () -> String
5242
5654
  def delimiter
5243
5655
  delimiter_loc.slice
@@ -5285,6 +5697,15 @@ module Prism
5285
5697
  def self.type
5286
5698
  :constant_path_target_node
5287
5699
  end
5700
+
5701
+ # Implements case-equality for the node. This is effectively == but without
5702
+ # comparing the value of locations. Locations are checked only for presence.
5703
+ def ===(other)
5704
+ other.is_a?(ConstantPathTargetNode) &&
5705
+ (parent === other.parent) &&
5706
+ (child === other.child) &&
5707
+ (delimiter_loc.nil? == other.delimiter_loc.nil?)
5708
+ end
5288
5709
  end
5289
5710
 
5290
5711
  # Represents writing to a constant path.
@@ -5341,20 +5762,31 @@ module Prism
5341
5762
  { target: target, operator_loc: operator_loc, value: value, location: location }
5342
5763
  end
5343
5764
 
5344
- # attr_reader target: ConstantPathNode
5765
+ # A node representing the constant path being written to.
5766
+ #
5767
+ # Foo::Bar = 1
5768
+ # ^^^^^^^^
5769
+ #
5770
+ # ::Foo = :abc
5771
+ # ^^^^^
5345
5772
  attr_reader :target
5346
5773
 
5347
- # attr_reader operator_loc: Location
5774
+ # The location of the `=` operator.
5775
+ #
5776
+ # ::ABC = 123
5777
+ # ^
5348
5778
  def operator_loc
5349
5779
  location = @operator_loc
5350
5780
  return location if location.is_a?(Location)
5351
5781
  @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
5352
5782
  end
5353
5783
 
5354
- # attr_reader value: Prism::node
5784
+ # 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).
5785
+ #
5786
+ # FOO::BAR = :abc
5787
+ # ^^^^
5355
5788
  attr_reader :value
5356
5789
 
5357
-
5358
5790
  # def operator: () -> String
5359
5791
  def operator
5360
5792
  operator_loc.slice
@@ -5398,6 +5830,15 @@ module Prism
5398
5830
  def self.type
5399
5831
  :constant_path_write_node
5400
5832
  end
5833
+
5834
+ # Implements case-equality for the node. This is effectively == but without
5835
+ # comparing the value of locations. Locations are checked only for presence.
5836
+ def ===(other)
5837
+ other.is_a?(ConstantPathWriteNode) &&
5838
+ (target === other.target) &&
5839
+ (operator_loc.nil? == other.operator_loc.nil?) &&
5840
+ (value === other.value)
5841
+ end
5401
5842
  end
5402
5843
 
5403
5844
  # Represents referencing a constant.
@@ -5453,7 +5894,6 @@ module Prism
5453
5894
  # SOME_CONSTANT # name `:SOME_CONSTANT`
5454
5895
  attr_reader :name
5455
5896
 
5456
-
5457
5897
  # def inspect(NodeInspector inspector) -> String
5458
5898
  def inspect(inspector = NodeInspector.new)
5459
5899
  inspector << inspector.header(self)
@@ -5488,6 +5928,13 @@ module Prism
5488
5928
  def self.type
5489
5929
  :constant_read_node
5490
5930
  end
5931
+
5932
+ # Implements case-equality for the node. This is effectively == but without
5933
+ # comparing the value of locations. Locations are checked only for presence.
5934
+ def ===(other)
5935
+ other.is_a?(ConstantReadNode) &&
5936
+ (name === other.name)
5937
+ end
5491
5938
  end
5492
5939
 
5493
5940
  # Represents writing to a constant in a context that doesn't have an explicit value.
@@ -5539,7 +5986,6 @@ module Prism
5539
5986
  # attr_reader name: Symbol
5540
5987
  attr_reader :name
5541
5988
 
5542
-
5543
5989
  # def inspect(NodeInspector inspector) -> String
5544
5990
  def inspect(inspector = NodeInspector.new)
5545
5991
  inspector << inspector.header(self)
@@ -5574,6 +6020,13 @@ module Prism
5574
6020
  def self.type
5575
6021
  :constant_target_node
5576
6022
  end
6023
+
6024
+ # Implements case-equality for the node. This is effectively == but without
6025
+ # comparing the value of locations. Locations are checked only for presence.
6026
+ def ===(other)
6027
+ other.is_a?(ConstantTargetNode) &&
6028
+ (name === other.name)
6029
+ end
5577
6030
  end
5578
6031
 
5579
6032
  # Represents writing to a constant.
@@ -5625,27 +6078,42 @@ module Prism
5625
6078
  { name: name, name_loc: name_loc, value: value, operator_loc: operator_loc, location: location }
5626
6079
  end
5627
6080
 
5628
- # attr_reader name: Symbol
6081
+ # The name of the [constant](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#constants).
6082
+ #
6083
+ # Foo = :bar # name `:Foo`
6084
+ #
6085
+ # XYZ = 1 # name `:XYZ`
5629
6086
  attr_reader :name
5630
6087
 
5631
- # attr_reader name_loc: Location
6088
+ # The location of the constant name.
6089
+ #
6090
+ # FOO = 1
6091
+ # ^^^
5632
6092
  def name_loc
5633
6093
  location = @name_loc
5634
6094
  return location if location.is_a?(Location)
5635
6095
  @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
5636
6096
  end
5637
6097
 
5638
- # attr_reader value: Prism::node
6098
+ # 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).
6099
+ #
6100
+ # FOO = :bar
6101
+ # ^^^^
6102
+ #
6103
+ # MyClass = Class.new
6104
+ # ^^^^^^^^^
5639
6105
  attr_reader :value
5640
6106
 
5641
- # attr_reader operator_loc: Location
6107
+ # The location of the `=` operator.
6108
+ #
6109
+ # FOO = :bar
6110
+ # ^
5642
6111
  def operator_loc
5643
6112
  location = @operator_loc
5644
6113
  return location if location.is_a?(Location)
5645
6114
  @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
5646
6115
  end
5647
6116
 
5648
-
5649
6117
  # def operator: () -> String
5650
6118
  def operator
5651
6119
  operator_loc.slice
@@ -5689,6 +6157,16 @@ module Prism
5689
6157
  def self.type
5690
6158
  :constant_write_node
5691
6159
  end
6160
+
6161
+ # Implements case-equality for the node. This is effectively == but without
6162
+ # comparing the value of locations. Locations are checked only for presence.
6163
+ def ===(other)
6164
+ other.is_a?(ConstantWriteNode) &&
6165
+ (name === other.name) &&
6166
+ (name_loc.nil? == other.name_loc.nil?) &&
6167
+ (value === other.value) &&
6168
+ (operator_loc.nil? == other.operator_loc.nil?)
6169
+ end
5692
6170
  end
5693
6171
 
5694
6172
  # Represents a method definition.
@@ -5847,7 +6325,6 @@ module Prism
5847
6325
  end
5848
6326
  end
5849
6327
 
5850
-
5851
6328
  # def def_keyword: () -> String
5852
6329
  def def_keyword
5853
6330
  def_keyword_loc.slice
@@ -5938,6 +6415,25 @@ module Prism
5938
6415
  def self.type
5939
6416
  :def_node
5940
6417
  end
6418
+
6419
+ # Implements case-equality for the node. This is effectively == but without
6420
+ # comparing the value of locations. Locations are checked only for presence.
6421
+ def ===(other)
6422
+ other.is_a?(DefNode) &&
6423
+ (name === other.name) &&
6424
+ (name_loc.nil? == other.name_loc.nil?) &&
6425
+ (receiver === other.receiver) &&
6426
+ (parameters === other.parameters) &&
6427
+ (body === other.body) &&
6428
+ (locals.length == other.locals.length) &&
6429
+ locals.zip(other.locals).all? { |left, right| left === right } &&
6430
+ (def_keyword_loc.nil? == other.def_keyword_loc.nil?) &&
6431
+ (operator_loc.nil? == other.operator_loc.nil?) &&
6432
+ (lparen_loc.nil? == other.lparen_loc.nil?) &&
6433
+ (rparen_loc.nil? == other.rparen_loc.nil?) &&
6434
+ (equal_loc.nil? == other.equal_loc.nil?) &&
6435
+ (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
6436
+ end
5941
6437
  end
5942
6438
 
5943
6439
  # Represents the use of the `defined?` keyword.
@@ -6025,7 +6521,6 @@ module Prism
6025
6521
  @keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
6026
6522
  end
6027
6523
 
6028
-
6029
6524
  # def lparen: () -> String?
6030
6525
  def lparen
6031
6526
  lparen_loc&.slice
@@ -6079,6 +6574,16 @@ module Prism
6079
6574
  def self.type
6080
6575
  :defined_node
6081
6576
  end
6577
+
6578
+ # Implements case-equality for the node. This is effectively == but without
6579
+ # comparing the value of locations. Locations are checked only for presence.
6580
+ def ===(other)
6581
+ other.is_a?(DefinedNode) &&
6582
+ (lparen_loc.nil? == other.lparen_loc.nil?) &&
6583
+ (value === other.value) &&
6584
+ (rparen_loc.nil? == other.rparen_loc.nil?) &&
6585
+ (keyword_loc.nil? == other.keyword_loc.nil?)
6586
+ end
6082
6587
  end
6083
6588
 
6084
6589
  # Represents an `else` clause in a `case`, `if`, or `unless` statement.
@@ -6154,7 +6659,6 @@ module Prism
6154
6659
  end
6155
6660
  end
6156
6661
 
6157
-
6158
6662
  # def else_keyword: () -> String
6159
6663
  def else_keyword
6160
6664
  else_keyword_loc.slice
@@ -6206,6 +6710,15 @@ module Prism
6206
6710
  def self.type
6207
6711
  :else_node
6208
6712
  end
6713
+
6714
+ # Implements case-equality for the node. This is effectively == but without
6715
+ # comparing the value of locations. Locations are checked only for presence.
6716
+ def ===(other)
6717
+ other.is_a?(ElseNode) &&
6718
+ (else_keyword_loc.nil? == other.else_keyword_loc.nil?) &&
6719
+ (statements === other.statements) &&
6720
+ (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
6721
+ end
6209
6722
  end
6210
6723
 
6211
6724
  # Represents an interpolated set of statements.
@@ -6275,7 +6788,6 @@ module Prism
6275
6788
  @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
6276
6789
  end
6277
6790
 
6278
-
6279
6791
  # def opening: () -> String
6280
6792
  def opening
6281
6793
  opening_loc.slice
@@ -6327,6 +6839,15 @@ module Prism
6327
6839
  def self.type
6328
6840
  :embedded_statements_node
6329
6841
  end
6842
+
6843
+ # Implements case-equality for the node. This is effectively == but without
6844
+ # comparing the value of locations. Locations are checked only for presence.
6845
+ def ===(other)
6846
+ other.is_a?(EmbeddedStatementsNode) &&
6847
+ (opening_loc.nil? == other.opening_loc.nil?) &&
6848
+ (statements === other.statements) &&
6849
+ (closing_loc.nil? == other.closing_loc.nil?)
6850
+ end
6330
6851
  end
6331
6852
 
6332
6853
  # Represents an interpolated variable.
@@ -6386,7 +6907,6 @@ module Prism
6386
6907
  # attr_reader variable: Prism::node
6387
6908
  attr_reader :variable
6388
6909
 
6389
-
6390
6910
  # def operator: () -> String
6391
6911
  def operator
6392
6912
  operator_loc.slice
@@ -6428,6 +6948,14 @@ module Prism
6428
6948
  def self.type
6429
6949
  :embedded_variable_node
6430
6950
  end
6951
+
6952
+ # Implements case-equality for the node. This is effectively == but without
6953
+ # comparing the value of locations. Locations are checked only for presence.
6954
+ def ===(other)
6955
+ other.is_a?(EmbeddedVariableNode) &&
6956
+ (operator_loc.nil? == other.operator_loc.nil?) &&
6957
+ (variable === other.variable)
6958
+ end
6431
6959
  end
6432
6960
 
6433
6961
  # Represents an `ensure` clause in a `begin` statement.
@@ -6501,7 +7029,6 @@ module Prism
6501
7029
  @end_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
6502
7030
  end
6503
7031
 
6504
-
6505
7032
  # def ensure_keyword: () -> String
6506
7033
  def ensure_keyword
6507
7034
  ensure_keyword_loc.slice
@@ -6553,6 +7080,15 @@ module Prism
6553
7080
  def self.type
6554
7081
  :ensure_node
6555
7082
  end
7083
+
7084
+ # Implements case-equality for the node. This is effectively == but without
7085
+ # comparing the value of locations. Locations are checked only for presence.
7086
+ def ===(other)
7087
+ other.is_a?(EnsureNode) &&
7088
+ (ensure_keyword_loc.nil? == other.ensure_keyword_loc.nil?) &&
7089
+ (statements === other.statements) &&
7090
+ (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
7091
+ end
6556
7092
  end
6557
7093
 
6558
7094
  # Represents the use of the literal `false` keyword.
@@ -6600,7 +7136,6 @@ module Prism
6600
7136
  { location: location }
6601
7137
  end
6602
7138
 
6603
-
6604
7139
  # def inspect(NodeInspector inspector) -> String
6605
7140
  def inspect(inspector = NodeInspector.new)
6606
7141
  inspector << inspector.header(self)
@@ -6634,6 +7169,12 @@ module Prism
6634
7169
  def self.type
6635
7170
  :false_node
6636
7171
  end
7172
+
7173
+ # Implements case-equality for the node. This is effectively == but without
7174
+ # comparing the value of locations. Locations are checked only for presence.
7175
+ def ===(other)
7176
+ other.is_a?(FalseNode)
7177
+ end
6637
7178
  end
6638
7179
 
6639
7180
  # Represents a find pattern in pattern matching.
@@ -6736,7 +7277,6 @@ module Prism
6736
7277
  end
6737
7278
  end
6738
7279
 
6739
-
6740
7280
  # def opening: () -> String?
6741
7281
  def opening
6742
7282
  opening_loc&.slice
@@ -6793,6 +7333,19 @@ module Prism
6793
7333
  def self.type
6794
7334
  :find_pattern_node
6795
7335
  end
7336
+
7337
+ # Implements case-equality for the node. This is effectively == but without
7338
+ # comparing the value of locations. Locations are checked only for presence.
7339
+ def ===(other)
7340
+ other.is_a?(FindPatternNode) &&
7341
+ (constant === other.constant) &&
7342
+ (left === other.left) &&
7343
+ (requireds.length == other.requireds.length) &&
7344
+ requireds.zip(other.requireds).all? { |left, right| left === right } &&
7345
+ (right === other.right) &&
7346
+ (opening_loc.nil? == other.opening_loc.nil?) &&
7347
+ (closing_loc.nil? == other.closing_loc.nil?)
7348
+ end
6796
7349
  end
6797
7350
 
6798
7351
  # Represents the use of the `..` or `...` operators to create flip flops.
@@ -6847,9 +7400,9 @@ module Prism
6847
7400
  { flags: flags, left: left, right: right, operator_loc: operator_loc, location: location }
6848
7401
  end
6849
7402
 
6850
- # private attr_reader flags: Integer
7403
+ # protected attr_reader flags: Integer
6851
7404
  attr_reader :flags
6852
- private :flags
7405
+ protected :flags
6853
7406
 
6854
7407
  # attr_reader left: Prism::node?
6855
7408
  attr_reader :left
@@ -6864,7 +7417,6 @@ module Prism
6864
7417
  @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
6865
7418
  end
6866
7419
 
6867
-
6868
7420
  # def exclude_end?: () -> bool
6869
7421
  def exclude_end?
6870
7422
  flags.anybits?(RangeFlags::EXCLUDE_END)
@@ -6923,6 +7475,16 @@ module Prism
6923
7475
  def self.type
6924
7476
  :flip_flop_node
6925
7477
  end
7478
+
7479
+ # Implements case-equality for the node. This is effectively == but without
7480
+ # comparing the value of locations. Locations are checked only for presence.
7481
+ def ===(other)
7482
+ other.is_a?(FlipFlopNode) &&
7483
+ (flags === other.flags) &&
7484
+ (left === other.left) &&
7485
+ (right === other.right) &&
7486
+ (operator_loc.nil? == other.operator_loc.nil?)
7487
+ end
6926
7488
  end
6927
7489
 
6928
7490
  # Represents a floating point number literal.
@@ -6974,7 +7536,6 @@ module Prism
6974
7536
  # The value of the floating point number as a Float.
6975
7537
  attr_reader :value
6976
7538
 
6977
-
6978
7539
  # def inspect(NodeInspector inspector) -> String
6979
7540
  def inspect(inspector = NodeInspector.new)
6980
7541
  inspector << inspector.header(self)
@@ -7009,6 +7570,13 @@ module Prism
7009
7570
  def self.type
7010
7571
  :float_node
7011
7572
  end
7573
+
7574
+ # Implements case-equality for the node. This is effectively == but without
7575
+ # comparing the value of locations. Locations are checked only for presence.
7576
+ def ===(other)
7577
+ other.is_a?(FloatNode) &&
7578
+ (value === other.value)
7579
+ end
7012
7580
  end
7013
7581
 
7014
7582
  # Represents the use of the `for` keyword.
@@ -7110,7 +7678,6 @@ module Prism
7110
7678
  @end_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
7111
7679
  end
7112
7680
 
7113
-
7114
7681
  # def for_keyword: () -> String
7115
7682
  def for_keyword
7116
7683
  for_keyword_loc.slice
@@ -7178,6 +7745,19 @@ module Prism
7178
7745
  def self.type
7179
7746
  :for_node
7180
7747
  end
7748
+
7749
+ # Implements case-equality for the node. This is effectively == but without
7750
+ # comparing the value of locations. Locations are checked only for presence.
7751
+ def ===(other)
7752
+ other.is_a?(ForNode) &&
7753
+ (index === other.index) &&
7754
+ (collection === other.collection) &&
7755
+ (statements === other.statements) &&
7756
+ (for_keyword_loc.nil? == other.for_keyword_loc.nil?) &&
7757
+ (in_keyword_loc.nil? == other.in_keyword_loc.nil?) &&
7758
+ (do_keyword_loc.nil? == other.do_keyword_loc.nil?) &&
7759
+ (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
7760
+ end
7181
7761
  end
7182
7762
 
7183
7763
  # Represents forwarding all arguments to this method to another method.
@@ -7227,7 +7807,6 @@ module Prism
7227
7807
  { location: location }
7228
7808
  end
7229
7809
 
7230
-
7231
7810
  # def inspect(NodeInspector inspector) -> String
7232
7811
  def inspect(inspector = NodeInspector.new)
7233
7812
  inspector << inspector.header(self)
@@ -7261,6 +7840,12 @@ module Prism
7261
7840
  def self.type
7262
7841
  :forwarding_arguments_node
7263
7842
  end
7843
+
7844
+ # Implements case-equality for the node. This is effectively == but without
7845
+ # comparing the value of locations. Locations are checked only for presence.
7846
+ def ===(other)
7847
+ other.is_a?(ForwardingArgumentsNode)
7848
+ end
7264
7849
  end
7265
7850
 
7266
7851
  # Represents the use of the forwarding parameter in a method, block, or lambda declaration.
@@ -7309,7 +7894,6 @@ module Prism
7309
7894
  { location: location }
7310
7895
  end
7311
7896
 
7312
-
7313
7897
  # def inspect(NodeInspector inspector) -> String
7314
7898
  def inspect(inspector = NodeInspector.new)
7315
7899
  inspector << inspector.header(self)
@@ -7343,6 +7927,12 @@ module Prism
7343
7927
  def self.type
7344
7928
  :forwarding_parameter_node
7345
7929
  end
7930
+
7931
+ # Implements case-equality for the node. This is effectively == but without
7932
+ # comparing the value of locations. Locations are checked only for presence.
7933
+ def ===(other)
7934
+ other.is_a?(ForwardingParameterNode)
7935
+ end
7346
7936
  end
7347
7937
 
7348
7938
  # Represents the use of the `super` keyword without parentheses or arguments.
@@ -7396,7 +7986,6 @@ module Prism
7396
7986
  # attr_reader block: BlockNode?
7397
7987
  attr_reader :block
7398
7988
 
7399
-
7400
7989
  # def inspect(NodeInspector inspector) -> String
7401
7990
  def inspect(inspector = NodeInspector.new)
7402
7991
  inspector << inspector.header(self)
@@ -7436,6 +8025,13 @@ module Prism
7436
8025
  def self.type
7437
8026
  :forwarding_super_node
7438
8027
  end
8028
+
8029
+ # Implements case-equality for the node. This is effectively == but without
8030
+ # comparing the value of locations. Locations are checked only for presence.
8031
+ def ===(other)
8032
+ other.is_a?(ForwardingSuperNode) &&
8033
+ (block === other.block)
8034
+ end
7439
8035
  end
7440
8036
 
7441
8037
  # Represents the use of the `&&=` operator for assignment to a global variable.
@@ -7507,7 +8103,6 @@ module Prism
7507
8103
  # attr_reader value: Prism::node
7508
8104
  attr_reader :value
7509
8105
 
7510
-
7511
8106
  # def operator: () -> String
7512
8107
  def operator
7513
8108
  operator_loc.slice
@@ -7551,6 +8146,16 @@ module Prism
7551
8146
  def self.type
7552
8147
  :global_variable_and_write_node
7553
8148
  end
8149
+
8150
+ # Implements case-equality for the node. This is effectively == but without
8151
+ # comparing the value of locations. Locations are checked only for presence.
8152
+ def ===(other)
8153
+ other.is_a?(GlobalVariableAndWriteNode) &&
8154
+ (name === other.name) &&
8155
+ (name_loc.nil? == other.name_loc.nil?) &&
8156
+ (operator_loc.nil? == other.operator_loc.nil?) &&
8157
+ (value === other.value)
8158
+ end
7554
8159
  end
7555
8160
 
7556
8161
  # Represents assigning to a global variable using an operator that isn't `=`.
@@ -7626,7 +8231,6 @@ module Prism
7626
8231
  # attr_reader operator: Symbol
7627
8232
  attr_reader :operator
7628
8233
 
7629
-
7630
8234
  # def inspect(NodeInspector inspector) -> String
7631
8235
  def inspect(inspector = NodeInspector.new)
7632
8236
  inspector << inspector.header(self)
@@ -7666,6 +8270,17 @@ module Prism
7666
8270
  def self.type
7667
8271
  :global_variable_operator_write_node
7668
8272
  end
8273
+
8274
+ # Implements case-equality for the node. This is effectively == but without
8275
+ # comparing the value of locations. Locations are checked only for presence.
8276
+ def ===(other)
8277
+ other.is_a?(GlobalVariableOperatorWriteNode) &&
8278
+ (name === other.name) &&
8279
+ (name_loc.nil? == other.name_loc.nil?) &&
8280
+ (operator_loc.nil? == other.operator_loc.nil?) &&
8281
+ (value === other.value) &&
8282
+ (operator === other.operator)
8283
+ end
7669
8284
  end
7670
8285
 
7671
8286
  # Represents the use of the `||=` operator for assignment to a global variable.
@@ -7737,7 +8352,6 @@ module Prism
7737
8352
  # attr_reader value: Prism::node
7738
8353
  attr_reader :value
7739
8354
 
7740
-
7741
8355
  # def operator: () -> String
7742
8356
  def operator
7743
8357
  operator_loc.slice
@@ -7781,6 +8395,16 @@ module Prism
7781
8395
  def self.type
7782
8396
  :global_variable_or_write_node
7783
8397
  end
8398
+
8399
+ # Implements case-equality for the node. This is effectively == but without
8400
+ # comparing the value of locations. Locations are checked only for presence.
8401
+ def ===(other)
8402
+ other.is_a?(GlobalVariableOrWriteNode) &&
8403
+ (name === other.name) &&
8404
+ (name_loc.nil? == other.name_loc.nil?) &&
8405
+ (operator_loc.nil? == other.operator_loc.nil?) &&
8406
+ (value === other.value)
8407
+ end
7784
8408
  end
7785
8409
 
7786
8410
  # Represents referencing a global variable.
@@ -7836,7 +8460,6 @@ module Prism
7836
8460
  # $_Test # name `:$_Test`
7837
8461
  attr_reader :name
7838
8462
 
7839
-
7840
8463
  # def inspect(NodeInspector inspector) -> String
7841
8464
  def inspect(inspector = NodeInspector.new)
7842
8465
  inspector << inspector.header(self)
@@ -7871,6 +8494,13 @@ module Prism
7871
8494
  def self.type
7872
8495
  :global_variable_read_node
7873
8496
  end
8497
+
8498
+ # Implements case-equality for the node. This is effectively == but without
8499
+ # comparing the value of locations. Locations are checked only for presence.
8500
+ def ===(other)
8501
+ other.is_a?(GlobalVariableReadNode) &&
8502
+ (name === other.name)
8503
+ end
7874
8504
  end
7875
8505
 
7876
8506
  # Represents writing to a global variable in a context that doesn't have an explicit value.
@@ -7922,7 +8552,6 @@ module Prism
7922
8552
  # attr_reader name: Symbol
7923
8553
  attr_reader :name
7924
8554
 
7925
-
7926
8555
  # def inspect(NodeInspector inspector) -> String
7927
8556
  def inspect(inspector = NodeInspector.new)
7928
8557
  inspector << inspector.header(self)
@@ -7957,6 +8586,13 @@ module Prism
7957
8586
  def self.type
7958
8587
  :global_variable_target_node
7959
8588
  end
8589
+
8590
+ # Implements case-equality for the node. This is effectively == but without
8591
+ # comparing the value of locations. Locations are checked only for presence.
8592
+ def ===(other)
8593
+ other.is_a?(GlobalVariableTargetNode) &&
8594
+ (name === other.name)
8595
+ end
7960
8596
  end
7961
8597
 
7962
8598
  # Represents writing to a global variable.
@@ -8008,27 +8644,42 @@ module Prism
8008
8644
  { name: name, name_loc: name_loc, value: value, operator_loc: operator_loc, location: location }
8009
8645
  end
8010
8646
 
8011
- # attr_reader name: Symbol
8647
+ # 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.
8648
+ #
8649
+ # $foo = :bar # name `:$foo`
8650
+ #
8651
+ # $_Test = 123 # name `:$_Test`
8012
8652
  attr_reader :name
8013
8653
 
8014
- # attr_reader name_loc: Location
8654
+ # The location of the global variable's name.
8655
+ #
8656
+ # $foo = :bar
8657
+ # ^^^^
8015
8658
  def name_loc
8016
8659
  location = @name_loc
8017
8660
  return location if location.is_a?(Location)
8018
8661
  @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
8019
8662
  end
8020
8663
 
8021
- # attr_reader value: Prism::node
8664
+ # 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).
8665
+ #
8666
+ # $foo = :bar
8667
+ # ^^^^
8668
+ #
8669
+ # $-xyz = 123
8670
+ # ^^^
8022
8671
  attr_reader :value
8023
8672
 
8024
- # attr_reader operator_loc: Location
8673
+ # The location of the `=` operator.
8674
+ #
8675
+ # $foo = :bar
8676
+ # ^
8025
8677
  def operator_loc
8026
8678
  location = @operator_loc
8027
8679
  return location if location.is_a?(Location)
8028
8680
  @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
8029
8681
  end
8030
8682
 
8031
-
8032
8683
  # def operator: () -> String
8033
8684
  def operator
8034
8685
  operator_loc.slice
@@ -8072,6 +8723,16 @@ module Prism
8072
8723
  def self.type
8073
8724
  :global_variable_write_node
8074
8725
  end
8726
+
8727
+ # Implements case-equality for the node. This is effectively == but without
8728
+ # comparing the value of locations. Locations are checked only for presence.
8729
+ def ===(other)
8730
+ other.is_a?(GlobalVariableWriteNode) &&
8731
+ (name === other.name) &&
8732
+ (name_loc.nil? == other.name_loc.nil?) &&
8733
+ (value === other.value) &&
8734
+ (operator_loc.nil? == other.operator_loc.nil?)
8735
+ end
8075
8736
  end
8076
8737
 
8077
8738
  # Represents a hash literal.
@@ -8151,7 +8812,6 @@ module Prism
8151
8812
  @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
8152
8813
  end
8153
8814
 
8154
-
8155
8815
  # def opening: () -> String
8156
8816
  def opening
8157
8817
  opening_loc.slice
@@ -8198,6 +8858,16 @@ module Prism
8198
8858
  def self.type
8199
8859
  :hash_node
8200
8860
  end
8861
+
8862
+ # Implements case-equality for the node. This is effectively == but without
8863
+ # comparing the value of locations. Locations are checked only for presence.
8864
+ def ===(other)
8865
+ other.is_a?(HashNode) &&
8866
+ (opening_loc.nil? == other.opening_loc.nil?) &&
8867
+ (elements.length == other.elements.length) &&
8868
+ elements.zip(other.elements).all? { |left, right| left === right } &&
8869
+ (closing_loc.nil? == other.closing_loc.nil?)
8870
+ end
8201
8871
  end
8202
8872
 
8203
8873
  # Represents a hash pattern in pattern matching.
@@ -8292,7 +8962,6 @@ module Prism
8292
8962
  end
8293
8963
  end
8294
8964
 
8295
-
8296
8965
  # def opening: () -> String?
8297
8966
  def opening
8298
8967
  opening_loc&.slice
@@ -8351,15 +9020,30 @@ module Prism
8351
9020
  def self.type
8352
9021
  :hash_pattern_node
8353
9022
  end
9023
+
9024
+ # Implements case-equality for the node. This is effectively == but without
9025
+ # comparing the value of locations. Locations are checked only for presence.
9026
+ def ===(other)
9027
+ other.is_a?(HashPatternNode) &&
9028
+ (constant === other.constant) &&
9029
+ (elements.length == other.elements.length) &&
9030
+ elements.zip(other.elements).all? { |left, right| left === right } &&
9031
+ (rest === other.rest) &&
9032
+ (opening_loc.nil? == other.opening_loc.nil?) &&
9033
+ (closing_loc.nil? == other.closing_loc.nil?)
9034
+ end
8354
9035
  end
8355
9036
 
8356
- # Represents the use of the `if` keyword, either in the block form or the modifier form.
9037
+ # Represents the use of the `if` keyword, either in the block form or the modifier form, or a ternary expression.
8357
9038
  #
8358
9039
  # bar if foo
8359
9040
  # ^^^^^^^^^^
8360
9041
  #
8361
9042
  # if foo then bar end
8362
9043
  # ^^^^^^^^^^^^^^^^^^^
9044
+ #
9045
+ # foo ? bar : baz
9046
+ # ^^^^^^^^^^^^^^^
8363
9047
  class IfNode < Node
8364
9048
  # 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
8365
9049
  def initialize(source, if_keyword_loc, predicate, then_keyword_loc, statements, consequent, end_keyword_loc, location)
@@ -8415,7 +9099,12 @@ module Prism
8415
9099
  { 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 }
8416
9100
  end
8417
9101
 
8418
- # attr_reader if_keyword_loc: Location?
9102
+ # The location of the `if` keyword if present.
9103
+ #
9104
+ # bar if foo
9105
+ # ^^
9106
+ #
9107
+ # The `if_keyword_loc` field will be `nil` when the `IfNode` represents a ternary expression.
8419
9108
  def if_keyword_loc
8420
9109
  location = @if_keyword_loc
8421
9110
  case location
@@ -8428,10 +9117,27 @@ module Prism
8428
9117
  end
8429
9118
  end
8430
9119
 
8431
- # attr_reader predicate: Prism::node
9120
+ # The node for the condition the `IfNode` is testing.
9121
+ #
9122
+ # if foo
9123
+ # ^^^
9124
+ # bar
9125
+ # end
9126
+ #
9127
+ # bar if foo
9128
+ # ^^^
9129
+ #
9130
+ # foo ? bar : baz
9131
+ # ^^^
8432
9132
  attr_reader :predicate
8433
9133
 
8434
- # attr_reader then_keyword_loc: Location?
9134
+ # The location of the `then` keyword (if present) or the `?` in a ternary expression, `nil` otherwise.
9135
+ #
9136
+ # if foo then bar end
9137
+ # ^^^^
9138
+ #
9139
+ # a ? b : c
9140
+ # ^
8435
9141
  def then_keyword_loc
8436
9142
  location = @then_keyword_loc
8437
9143
  case location
@@ -8444,13 +9150,37 @@ module Prism
8444
9150
  end
8445
9151
  end
8446
9152
 
8447
- # attr_reader statements: StatementsNode?
9153
+ # Represents the body of statements that will be executed when the predicate is evaluated as truthy. Will be `nil` when no body is provided.
9154
+ #
9155
+ # if foo
9156
+ # bar
9157
+ # ^^^
9158
+ # baz
9159
+ # ^^^
9160
+ # end
8448
9161
  attr_reader :statements
8449
9162
 
8450
- # attr_reader consequent: Prism::node?
9163
+ # Represents an `ElseNode` or an `IfNode` when there is an `else` or an `elsif` in the `if` statement.
9164
+ #
9165
+ # if foo
9166
+ # bar
9167
+ # elsif baz
9168
+ # ^^^^^^^^^
9169
+ # qux
9170
+ # ^^^
9171
+ # end
9172
+ # ^^^
9173
+ #
9174
+ # if foo then bar else baz end
9175
+ # ^^^^^^^^^^^^
8451
9176
  attr_reader :consequent
8452
9177
 
8453
- # attr_reader end_keyword_loc: Location?
9178
+ # The location of the `end` keyword if present, `nil` otherwise.
9179
+ #
9180
+ # if foo
9181
+ # bar
9182
+ # end
9183
+ # ^^^
8454
9184
  def end_keyword_loc
8455
9185
  location = @end_keyword_loc
8456
9186
  case location
@@ -8463,7 +9193,6 @@ module Prism
8463
9193
  end
8464
9194
  end
8465
9195
 
8466
-
8467
9196
  # def if_keyword: () -> String?
8468
9197
  def if_keyword
8469
9198
  if_keyword_loc&.slice
@@ -8529,6 +9258,18 @@ module Prism
8529
9258
  def self.type
8530
9259
  :if_node
8531
9260
  end
9261
+
9262
+ # Implements case-equality for the node. This is effectively == but without
9263
+ # comparing the value of locations. Locations are checked only for presence.
9264
+ def ===(other)
9265
+ other.is_a?(IfNode) &&
9266
+ (if_keyword_loc.nil? == other.if_keyword_loc.nil?) &&
9267
+ (predicate === other.predicate) &&
9268
+ (then_keyword_loc.nil? == other.then_keyword_loc.nil?) &&
9269
+ (statements === other.statements) &&
9270
+ (consequent === other.consequent) &&
9271
+ (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
9272
+ end
8532
9273
  end
8533
9274
 
8534
9275
  # Represents an imaginary number literal.
@@ -8580,7 +9321,6 @@ module Prism
8580
9321
  # attr_reader numeric: FloatNode | IntegerNode | RationalNode
8581
9322
  attr_reader :numeric
8582
9323
 
8583
-
8584
9324
  # def inspect(NodeInspector inspector) -> String
8585
9325
  def inspect(inspector = NodeInspector.new)
8586
9326
  inspector << inspector.header(self)
@@ -8616,6 +9356,13 @@ module Prism
8616
9356
  def self.type
8617
9357
  :imaginary_node
8618
9358
  end
9359
+
9360
+ # Implements case-equality for the node. This is effectively == but without
9361
+ # comparing the value of locations. Locations are checked only for presence.
9362
+ def ===(other)
9363
+ other.is_a?(ImaginaryNode) &&
9364
+ (numeric === other.numeric)
9365
+ end
8619
9366
  end
8620
9367
 
8621
9368
  # 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
8673
9420
  # attr_reader value: Prism::node
8674
9421
  attr_reader :value
8675
9422
 
8676
-
8677
9423
  # def inspect(NodeInspector inspector) -> String
8678
9424
  def inspect(inspector = NodeInspector.new)
8679
9425
  inspector << inspector.header(self)
@@ -8709,6 +9455,13 @@ module Prism
8709
9455
  def self.type
8710
9456
  :implicit_node
8711
9457
  end
9458
+
9459
+ # Implements case-equality for the node. This is effectively == but without
9460
+ # comparing the value of locations. Locations are checked only for presence.
9461
+ def ===(other)
9462
+ other.is_a?(ImplicitNode) &&
9463
+ (value === other.value)
9464
+ end
8712
9465
  end
8713
9466
 
8714
9467
  # Represents using a trailing comma to indicate an implicit rest parameter.
@@ -8765,7 +9518,6 @@ module Prism
8765
9518
  { location: location }
8766
9519
  end
8767
9520
 
8768
-
8769
9521
  # def inspect(NodeInspector inspector) -> String
8770
9522
  def inspect(inspector = NodeInspector.new)
8771
9523
  inspector << inspector.header(self)
@@ -8799,6 +9551,12 @@ module Prism
8799
9551
  def self.type
8800
9552
  :implicit_rest_node
8801
9553
  end
9554
+
9555
+ # Implements case-equality for the node. This is effectively == but without
9556
+ # comparing the value of locations. Locations are checked only for presence.
9557
+ def ===(other)
9558
+ other.is_a?(ImplicitRestNode)
9559
+ end
8802
9560
  end
8803
9561
 
8804
9562
  # Represents the use of the `in` keyword in a case statement.
@@ -8879,7 +9637,6 @@ module Prism
8879
9637
  end
8880
9638
  end
8881
9639
 
8882
-
8883
9640
  # def in: () -> String
8884
9641
  def in
8885
9642
  in_loc.slice
@@ -8933,6 +9690,16 @@ module Prism
8933
9690
  def self.type
8934
9691
  :in_node
8935
9692
  end
9693
+
9694
+ # Implements case-equality for the node. This is effectively == but without
9695
+ # comparing the value of locations. Locations are checked only for presence.
9696
+ def ===(other)
9697
+ other.is_a?(InNode) &&
9698
+ (pattern === other.pattern) &&
9699
+ (statements === other.statements) &&
9700
+ (in_loc.nil? == other.in_loc.nil?) &&
9701
+ (then_loc.nil? == other.then_loc.nil?)
9702
+ end
8936
9703
  end
8937
9704
 
8938
9705
  # Represents the use of the `&&=` operator on a call to the `[]` method.
@@ -8994,9 +9761,9 @@ module Prism
8994
9761
  { 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 }
8995
9762
  end
8996
9763
 
8997
- # private attr_reader flags: Integer
9764
+ # protected attr_reader flags: Integer
8998
9765
  attr_reader :flags
8999
- private :flags
9766
+ protected :flags
9000
9767
 
9001
9768
  # attr_reader receiver: Prism::node?
9002
9769
  attr_reader :receiver
@@ -9044,7 +9811,6 @@ module Prism
9044
9811
  # attr_reader value: Prism::node
9045
9812
  attr_reader :value
9046
9813
 
9047
-
9048
9814
  # def safe_navigation?: () -> bool
9049
9815
  def safe_navigation?
9050
9816
  flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -9144,6 +9910,21 @@ module Prism
9144
9910
  def self.type
9145
9911
  :index_and_write_node
9146
9912
  end
9913
+
9914
+ # Implements case-equality for the node. This is effectively == but without
9915
+ # comparing the value of locations. Locations are checked only for presence.
9916
+ def ===(other)
9917
+ other.is_a?(IndexAndWriteNode) &&
9918
+ (flags === other.flags) &&
9919
+ (receiver === other.receiver) &&
9920
+ (call_operator_loc.nil? == other.call_operator_loc.nil?) &&
9921
+ (opening_loc.nil? == other.opening_loc.nil?) &&
9922
+ (arguments === other.arguments) &&
9923
+ (closing_loc.nil? == other.closing_loc.nil?) &&
9924
+ (block === other.block) &&
9925
+ (operator_loc.nil? == other.operator_loc.nil?) &&
9926
+ (value === other.value)
9927
+ end
9147
9928
  end
9148
9929
 
9149
9930
  # Represents the use of an assignment operator on a call to `[]`.
@@ -9206,9 +9987,9 @@ module Prism
9206
9987
  { 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 }
9207
9988
  end
9208
9989
 
9209
- # private attr_reader flags: Integer
9990
+ # protected attr_reader flags: Integer
9210
9991
  attr_reader :flags
9211
- private :flags
9992
+ protected :flags
9212
9993
 
9213
9994
  # attr_reader receiver: Prism::node?
9214
9995
  attr_reader :receiver
@@ -9259,7 +10040,6 @@ module Prism
9259
10040
  # attr_reader value: Prism::node
9260
10041
  attr_reader :value
9261
10042
 
9262
-
9263
10043
  # def safe_navigation?: () -> bool
9264
10044
  def safe_navigation?
9265
10045
  flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -9355,6 +10135,22 @@ module Prism
9355
10135
  def self.type
9356
10136
  :index_operator_write_node
9357
10137
  end
10138
+
10139
+ # Implements case-equality for the node. This is effectively == but without
10140
+ # comparing the value of locations. Locations are checked only for presence.
10141
+ def ===(other)
10142
+ other.is_a?(IndexOperatorWriteNode) &&
10143
+ (flags === other.flags) &&
10144
+ (receiver === other.receiver) &&
10145
+ (call_operator_loc.nil? == other.call_operator_loc.nil?) &&
10146
+ (opening_loc.nil? == other.opening_loc.nil?) &&
10147
+ (arguments === other.arguments) &&
10148
+ (closing_loc.nil? == other.closing_loc.nil?) &&
10149
+ (block === other.block) &&
10150
+ (operator === other.operator) &&
10151
+ (operator_loc.nil? == other.operator_loc.nil?) &&
10152
+ (value === other.value)
10153
+ end
9358
10154
  end
9359
10155
 
9360
10156
  # Represents the use of the `||=` operator on a call to `[]`.
@@ -9416,9 +10212,9 @@ module Prism
9416
10212
  { 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 }
9417
10213
  end
9418
10214
 
9419
- # private attr_reader flags: Integer
10215
+ # protected attr_reader flags: Integer
9420
10216
  attr_reader :flags
9421
- private :flags
10217
+ protected :flags
9422
10218
 
9423
10219
  # attr_reader receiver: Prism::node?
9424
10220
  attr_reader :receiver
@@ -9466,7 +10262,6 @@ module Prism
9466
10262
  # attr_reader value: Prism::node
9467
10263
  attr_reader :value
9468
10264
 
9469
-
9470
10265
  # def safe_navigation?: () -> bool
9471
10266
  def safe_navigation?
9472
10267
  flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -9566,6 +10361,21 @@ module Prism
9566
10361
  def self.type
9567
10362
  :index_or_write_node
9568
10363
  end
10364
+
10365
+ # Implements case-equality for the node. This is effectively == but without
10366
+ # comparing the value of locations. Locations are checked only for presence.
10367
+ def ===(other)
10368
+ other.is_a?(IndexOrWriteNode) &&
10369
+ (flags === other.flags) &&
10370
+ (receiver === other.receiver) &&
10371
+ (call_operator_loc.nil? == other.call_operator_loc.nil?) &&
10372
+ (opening_loc.nil? == other.opening_loc.nil?) &&
10373
+ (arguments === other.arguments) &&
10374
+ (closing_loc.nil? == other.closing_loc.nil?) &&
10375
+ (block === other.block) &&
10376
+ (operator_loc.nil? == other.operator_loc.nil?) &&
10377
+ (value === other.value)
10378
+ end
9569
10379
  end
9570
10380
 
9571
10381
  # Represents assigning to an index.
@@ -9631,9 +10441,9 @@ module Prism
9631
10441
  { flags: flags, receiver: receiver, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, location: location }
9632
10442
  end
9633
10443
 
9634
- # private attr_reader flags: Integer
10444
+ # protected attr_reader flags: Integer
9635
10445
  attr_reader :flags
9636
- private :flags
10446
+ protected :flags
9637
10447
 
9638
10448
  # attr_reader receiver: Prism::node
9639
10449
  attr_reader :receiver
@@ -9658,7 +10468,6 @@ module Prism
9658
10468
  # attr_reader block: Prism::node?
9659
10469
  attr_reader :block
9660
10470
 
9661
-
9662
10471
  # def safe_navigation?: () -> bool
9663
10472
  def safe_navigation?
9664
10473
  flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -9740,6 +10549,18 @@ module Prism
9740
10549
  def self.type
9741
10550
  :index_target_node
9742
10551
  end
10552
+
10553
+ # Implements case-equality for the node. This is effectively == but without
10554
+ # comparing the value of locations. Locations are checked only for presence.
10555
+ def ===(other)
10556
+ other.is_a?(IndexTargetNode) &&
10557
+ (flags === other.flags) &&
10558
+ (receiver === other.receiver) &&
10559
+ (opening_loc.nil? == other.opening_loc.nil?) &&
10560
+ (arguments === other.arguments) &&
10561
+ (closing_loc.nil? == other.closing_loc.nil?) &&
10562
+ (block === other.block)
10563
+ end
9743
10564
  end
9744
10565
 
9745
10566
  # Represents the use of the `&&=` operator for assignment to an instance variable.
@@ -9811,7 +10632,6 @@ module Prism
9811
10632
  # attr_reader value: Prism::node
9812
10633
  attr_reader :value
9813
10634
 
9814
-
9815
10635
  # def operator: () -> String
9816
10636
  def operator
9817
10637
  operator_loc.slice
@@ -9855,6 +10675,16 @@ module Prism
9855
10675
  def self.type
9856
10676
  :instance_variable_and_write_node
9857
10677
  end
10678
+
10679
+ # Implements case-equality for the node. This is effectively == but without
10680
+ # comparing the value of locations. Locations are checked only for presence.
10681
+ def ===(other)
10682
+ other.is_a?(InstanceVariableAndWriteNode) &&
10683
+ (name === other.name) &&
10684
+ (name_loc.nil? == other.name_loc.nil?) &&
10685
+ (operator_loc.nil? == other.operator_loc.nil?) &&
10686
+ (value === other.value)
10687
+ end
9858
10688
  end
9859
10689
 
9860
10690
  # Represents assigning to an instance variable using an operator that isn't `=`.
@@ -9930,7 +10760,6 @@ module Prism
9930
10760
  # attr_reader operator: Symbol
9931
10761
  attr_reader :operator
9932
10762
 
9933
-
9934
10763
  # def inspect(NodeInspector inspector) -> String
9935
10764
  def inspect(inspector = NodeInspector.new)
9936
10765
  inspector << inspector.header(self)
@@ -9970,6 +10799,17 @@ module Prism
9970
10799
  def self.type
9971
10800
  :instance_variable_operator_write_node
9972
10801
  end
10802
+
10803
+ # Implements case-equality for the node. This is effectively == but without
10804
+ # comparing the value of locations. Locations are checked only for presence.
10805
+ def ===(other)
10806
+ other.is_a?(InstanceVariableOperatorWriteNode) &&
10807
+ (name === other.name) &&
10808
+ (name_loc.nil? == other.name_loc.nil?) &&
10809
+ (operator_loc.nil? == other.operator_loc.nil?) &&
10810
+ (value === other.value) &&
10811
+ (operator === other.operator)
10812
+ end
9973
10813
  end
9974
10814
 
9975
10815
  # Represents the use of the `||=` operator for assignment to an instance variable.
@@ -10041,7 +10881,6 @@ module Prism
10041
10881
  # attr_reader value: Prism::node
10042
10882
  attr_reader :value
10043
10883
 
10044
-
10045
10884
  # def operator: () -> String
10046
10885
  def operator
10047
10886
  operator_loc.slice
@@ -10085,6 +10924,16 @@ module Prism
10085
10924
  def self.type
10086
10925
  :instance_variable_or_write_node
10087
10926
  end
10927
+
10928
+ # Implements case-equality for the node. This is effectively == but without
10929
+ # comparing the value of locations. Locations are checked only for presence.
10930
+ def ===(other)
10931
+ other.is_a?(InstanceVariableOrWriteNode) &&
10932
+ (name === other.name) &&
10933
+ (name_loc.nil? == other.name_loc.nil?) &&
10934
+ (operator_loc.nil? == other.operator_loc.nil?) &&
10935
+ (value === other.value)
10936
+ end
10088
10937
  end
10089
10938
 
10090
10939
  # Represents referencing an instance variable.
@@ -10140,7 +10989,6 @@ module Prism
10140
10989
  # @_test # name `:@_test`
10141
10990
  attr_reader :name
10142
10991
 
10143
-
10144
10992
  # def inspect(NodeInspector inspector) -> String
10145
10993
  def inspect(inspector = NodeInspector.new)
10146
10994
  inspector << inspector.header(self)
@@ -10175,6 +11023,13 @@ module Prism
10175
11023
  def self.type
10176
11024
  :instance_variable_read_node
10177
11025
  end
11026
+
11027
+ # Implements case-equality for the node. This is effectively == but without
11028
+ # comparing the value of locations. Locations are checked only for presence.
11029
+ def ===(other)
11030
+ other.is_a?(InstanceVariableReadNode) &&
11031
+ (name === other.name)
11032
+ end
10178
11033
  end
10179
11034
 
10180
11035
  # Represents writing to an instance variable in a context that doesn't have an explicit value.
@@ -10226,7 +11081,6 @@ module Prism
10226
11081
  # attr_reader name: Symbol
10227
11082
  attr_reader :name
10228
11083
 
10229
-
10230
11084
  # def inspect(NodeInspector inspector) -> String
10231
11085
  def inspect(inspector = NodeInspector.new)
10232
11086
  inspector << inspector.header(self)
@@ -10261,6 +11115,13 @@ module Prism
10261
11115
  def self.type
10262
11116
  :instance_variable_target_node
10263
11117
  end
11118
+
11119
+ # Implements case-equality for the node. This is effectively == but without
11120
+ # comparing the value of locations. Locations are checked only for presence.
11121
+ def ===(other)
11122
+ other.is_a?(InstanceVariableTargetNode) &&
11123
+ (name === other.name)
11124
+ end
10264
11125
  end
10265
11126
 
10266
11127
  # Represents writing to an instance variable.
@@ -10329,8 +11190,7 @@ module Prism
10329
11190
  @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
10330
11191
  end
10331
11192
 
10332
- # The value to assign to the instance variable. Can be any node that
10333
- # represents a non-void expression.
11193
+ # 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).
10334
11194
  #
10335
11195
  # @foo = :bar
10336
11196
  # ^^^^
@@ -10349,7 +11209,6 @@ module Prism
10349
11209
  @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
10350
11210
  end
10351
11211
 
10352
-
10353
11212
  # def operator: () -> String
10354
11213
  def operator
10355
11214
  operator_loc.slice
@@ -10393,6 +11252,16 @@ module Prism
10393
11252
  def self.type
10394
11253
  :instance_variable_write_node
10395
11254
  end
11255
+
11256
+ # Implements case-equality for the node. This is effectively == but without
11257
+ # comparing the value of locations. Locations are checked only for presence.
11258
+ def ===(other)
11259
+ other.is_a?(InstanceVariableWriteNode) &&
11260
+ (name === other.name) &&
11261
+ (name_loc.nil? == other.name_loc.nil?) &&
11262
+ (value === other.value) &&
11263
+ (operator_loc.nil? == other.operator_loc.nil?)
11264
+ end
10396
11265
  end
10397
11266
 
10398
11267
  # Represents an integer number literal.
@@ -10442,14 +11311,13 @@ module Prism
10442
11311
  { flags: flags, value: value, location: location }
10443
11312
  end
10444
11313
 
10445
- # private attr_reader flags: Integer
11314
+ # protected attr_reader flags: Integer
10446
11315
  attr_reader :flags
10447
- private :flags
11316
+ protected :flags
10448
11317
 
10449
11318
  # The value of the integer literal as a number.
10450
11319
  attr_reader :value
10451
11320
 
10452
-
10453
11321
  # def binary?: () -> bool
10454
11322
  def binary?
10455
11323
  flags.anybits?(IntegerBaseFlags::BINARY)
@@ -10506,6 +11374,14 @@ module Prism
10506
11374
  def self.type
10507
11375
  :integer_node
10508
11376
  end
11377
+
11378
+ # Implements case-equality for the node. This is effectively == but without
11379
+ # comparing the value of locations. Locations are checked only for presence.
11380
+ def ===(other)
11381
+ other.is_a?(IntegerNode) &&
11382
+ (flags === other.flags) &&
11383
+ (value === other.value)
11384
+ end
10509
11385
  end
10510
11386
 
10511
11387
  # 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
10562
11438
  { flags: flags, opening_loc: opening_loc, parts: parts, closing_loc: closing_loc, location: location }
10563
11439
  end
10564
11440
 
10565
- # private attr_reader flags: Integer
11441
+ # protected attr_reader flags: Integer
10566
11442
  attr_reader :flags
10567
- private :flags
11443
+ protected :flags
10568
11444
 
10569
11445
  # attr_reader opening_loc: Location
10570
11446
  def opening_loc
@@ -10583,7 +11459,6 @@ module Prism
10583
11459
  @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
10584
11460
  end
10585
11461
 
10586
-
10587
11462
  # def ignore_case?: () -> bool
10588
11463
  def ignore_case?
10589
11464
  flags.anybits?(RegularExpressionFlags::IGNORE_CASE)
@@ -10687,6 +11562,17 @@ module Prism
10687
11562
  def self.type
10688
11563
  :interpolated_match_last_line_node
10689
11564
  end
11565
+
11566
+ # Implements case-equality for the node. This is effectively == but without
11567
+ # comparing the value of locations. Locations are checked only for presence.
11568
+ def ===(other)
11569
+ other.is_a?(InterpolatedMatchLastLineNode) &&
11570
+ (flags === other.flags) &&
11571
+ (opening_loc.nil? == other.opening_loc.nil?) &&
11572
+ (parts.length == other.parts.length) &&
11573
+ parts.zip(other.parts).all? { |left, right| left === right } &&
11574
+ (closing_loc.nil? == other.closing_loc.nil?)
11575
+ end
10690
11576
  end
10691
11577
 
10692
11578
  # Represents a regular expression literal that contains interpolation.
@@ -10743,9 +11629,9 @@ module Prism
10743
11629
  { flags: flags, opening_loc: opening_loc, parts: parts, closing_loc: closing_loc, location: location }
10744
11630
  end
10745
11631
 
10746
- # private attr_reader flags: Integer
11632
+ # protected attr_reader flags: Integer
10747
11633
  attr_reader :flags
10748
- private :flags
11634
+ protected :flags
10749
11635
 
10750
11636
  # attr_reader opening_loc: Location
10751
11637
  def opening_loc
@@ -10764,7 +11650,6 @@ module Prism
10764
11650
  @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
10765
11651
  end
10766
11652
 
10767
-
10768
11653
  # def ignore_case?: () -> bool
10769
11654
  def ignore_case?
10770
11655
  flags.anybits?(RegularExpressionFlags::IGNORE_CASE)
@@ -10868,6 +11753,17 @@ module Prism
10868
11753
  def self.type
10869
11754
  :interpolated_regular_expression_node
10870
11755
  end
11756
+
11757
+ # Implements case-equality for the node. This is effectively == but without
11758
+ # comparing the value of locations. Locations are checked only for presence.
11759
+ def ===(other)
11760
+ other.is_a?(InterpolatedRegularExpressionNode) &&
11761
+ (flags === other.flags) &&
11762
+ (opening_loc.nil? == other.opening_loc.nil?) &&
11763
+ (parts.length == other.parts.length) &&
11764
+ parts.zip(other.parts).all? { |left, right| left === right } &&
11765
+ (closing_loc.nil? == other.closing_loc.nil?)
11766
+ end
10871
11767
  end
10872
11768
 
10873
11769
  # Represents a string literal that contains interpolation.
@@ -10924,9 +11820,9 @@ module Prism
10924
11820
  { flags: flags, opening_loc: opening_loc, parts: parts, closing_loc: closing_loc, location: location }
10925
11821
  end
10926
11822
 
10927
- # private attr_reader flags: Integer
11823
+ # protected attr_reader flags: Integer
10928
11824
  attr_reader :flags
10929
- private :flags
11825
+ protected :flags
10930
11826
 
10931
11827
  # attr_reader opening_loc: Location?
10932
11828
  def opening_loc
@@ -10957,7 +11853,6 @@ module Prism
10957
11853
  end
10958
11854
  end
10959
11855
 
10960
-
10961
11856
  # def frozen?: () -> bool
10962
11857
  def frozen?
10963
11858
  flags.anybits?(InterpolatedStringNodeFlags::FROZEN)
@@ -11016,6 +11911,17 @@ module Prism
11016
11911
  def self.type
11017
11912
  :interpolated_string_node
11018
11913
  end
11914
+
11915
+ # Implements case-equality for the node. This is effectively == but without
11916
+ # comparing the value of locations. Locations are checked only for presence.
11917
+ def ===(other)
11918
+ other.is_a?(InterpolatedStringNode) &&
11919
+ (flags === other.flags) &&
11920
+ (opening_loc.nil? == other.opening_loc.nil?) &&
11921
+ (parts.length == other.parts.length) &&
11922
+ parts.zip(other.parts).all? { |left, right| left === right } &&
11923
+ (closing_loc.nil? == other.closing_loc.nil?)
11924
+ end
11019
11925
  end
11020
11926
 
11021
11927
  # Represents a symbol literal that contains interpolation.
@@ -11100,7 +12006,6 @@ module Prism
11100
12006
  end
11101
12007
  end
11102
12008
 
11103
-
11104
12009
  # def opening: () -> String?
11105
12010
  def opening
11106
12011
  opening_loc&.slice
@@ -11147,6 +12052,16 @@ module Prism
11147
12052
  def self.type
11148
12053
  :interpolated_symbol_node
11149
12054
  end
12055
+
12056
+ # Implements case-equality for the node. This is effectively == but without
12057
+ # comparing the value of locations. Locations are checked only for presence.
12058
+ def ===(other)
12059
+ other.is_a?(InterpolatedSymbolNode) &&
12060
+ (opening_loc.nil? == other.opening_loc.nil?) &&
12061
+ (parts.length == other.parts.length) &&
12062
+ parts.zip(other.parts).all? { |left, right| left === right } &&
12063
+ (closing_loc.nil? == other.closing_loc.nil?)
12064
+ end
11150
12065
  end
11151
12066
 
11152
12067
  # Represents an xstring literal that contains interpolation.
@@ -11219,7 +12134,6 @@ module Prism
11219
12134
  @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
11220
12135
  end
11221
12136
 
11222
-
11223
12137
  # def opening: () -> String
11224
12138
  def opening
11225
12139
  opening_loc.slice
@@ -11266,6 +12180,16 @@ module Prism
11266
12180
  def self.type
11267
12181
  :interpolated_x_string_node
11268
12182
  end
12183
+
12184
+ # Implements case-equality for the node. This is effectively == but without
12185
+ # comparing the value of locations. Locations are checked only for presence.
12186
+ def ===(other)
12187
+ other.is_a?(InterpolatedXStringNode) &&
12188
+ (opening_loc.nil? == other.opening_loc.nil?) &&
12189
+ (parts.length == other.parts.length) &&
12190
+ parts.zip(other.parts).all? { |left, right| left === right } &&
12191
+ (closing_loc.nil? == other.closing_loc.nil?)
12192
+ end
11269
12193
  end
11270
12194
 
11271
12195
  # Represents an implicit set of parameters through the use of the `it` keyword within a block or lambda.
@@ -11313,7 +12237,6 @@ module Prism
11313
12237
  { location: location }
11314
12238
  end
11315
12239
 
11316
-
11317
12240
  # def inspect(NodeInspector inspector) -> String
11318
12241
  def inspect(inspector = NodeInspector.new)
11319
12242
  inspector << inspector.header(self)
@@ -11347,6 +12270,12 @@ module Prism
11347
12270
  def self.type
11348
12271
  :it_parameters_node
11349
12272
  end
12273
+
12274
+ # Implements case-equality for the node. This is effectively == but without
12275
+ # comparing the value of locations. Locations are checked only for presence.
12276
+ def ===(other)
12277
+ other.is_a?(ItParametersNode)
12278
+ end
11350
12279
  end
11351
12280
 
11352
12281
  # Represents a hash literal without opening and closing braces.
@@ -11396,14 +12325,13 @@ module Prism
11396
12325
  { flags: flags, elements: elements, location: location }
11397
12326
  end
11398
12327
 
11399
- # private attr_reader flags: Integer
12328
+ # protected attr_reader flags: Integer
11400
12329
  attr_reader :flags
11401
- private :flags
12330
+ protected :flags
11402
12331
 
11403
12332
  # attr_reader elements: Array[AssocNode | AssocSplatNode]
11404
12333
  attr_reader :elements
11405
12334
 
11406
-
11407
12335
  # def symbol_keys?: () -> bool
11408
12336
  def symbol_keys?
11409
12337
  flags.anybits?(KeywordHashNodeFlags::SYMBOL_KEYS)
@@ -11445,6 +12373,15 @@ module Prism
11445
12373
  def self.type
11446
12374
  :keyword_hash_node
11447
12375
  end
12376
+
12377
+ # Implements case-equality for the node. This is effectively == but without
12378
+ # comparing the value of locations. Locations are checked only for presence.
12379
+ def ===(other)
12380
+ other.is_a?(KeywordHashNode) &&
12381
+ (flags === other.flags) &&
12382
+ (elements.length == other.elements.length) &&
12383
+ elements.zip(other.elements).all? { |left, right| left === right }
12384
+ end
11448
12385
  end
11449
12386
 
11450
12387
  # Represents a keyword rest parameter to a method, block, or lambda definition.
@@ -11497,9 +12434,9 @@ module Prism
11497
12434
  { flags: flags, name: name, name_loc: name_loc, operator_loc: operator_loc, location: location }
11498
12435
  end
11499
12436
 
11500
- # private attr_reader flags: Integer
12437
+ # protected attr_reader flags: Integer
11501
12438
  attr_reader :flags
11502
- private :flags
12439
+ protected :flags
11503
12440
 
11504
12441
  # attr_reader name: Symbol?
11505
12442
  attr_reader :name
@@ -11524,7 +12461,6 @@ module Prism
11524
12461
  @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
11525
12462
  end
11526
12463
 
11527
-
11528
12464
  # def repeated_parameter?: () -> bool
11529
12465
  def repeated_parameter?
11530
12466
  flags.anybits?(ParameterFlags::REPEATED_PARAMETER)
@@ -11577,6 +12513,16 @@ module Prism
11577
12513
  def self.type
11578
12514
  :keyword_rest_parameter_node
11579
12515
  end
12516
+
12517
+ # Implements case-equality for the node. This is effectively == but without
12518
+ # comparing the value of locations. Locations are checked only for presence.
12519
+ def ===(other)
12520
+ other.is_a?(KeywordRestParameterNode) &&
12521
+ (flags === other.flags) &&
12522
+ (name === other.name) &&
12523
+ (name_loc.nil? == other.name_loc.nil?) &&
12524
+ (operator_loc.nil? == other.operator_loc.nil?)
12525
+ end
11580
12526
  end
11581
12527
 
11582
12528
  # Represents using a lambda literal (not the lambda method call).
@@ -11663,7 +12609,6 @@ module Prism
11663
12609
  # attr_reader body: Prism::node?
11664
12610
  attr_reader :body
11665
12611
 
11666
-
11667
12612
  # def operator: () -> String
11668
12613
  def operator
11669
12614
  operator_loc.slice
@@ -11728,6 +12673,19 @@ module Prism
11728
12673
  def self.type
11729
12674
  :lambda_node
11730
12675
  end
12676
+
12677
+ # Implements case-equality for the node. This is effectively == but without
12678
+ # comparing the value of locations. Locations are checked only for presence.
12679
+ def ===(other)
12680
+ other.is_a?(LambdaNode) &&
12681
+ (locals.length == other.locals.length) &&
12682
+ locals.zip(other.locals).all? { |left, right| left === right } &&
12683
+ (operator_loc.nil? == other.operator_loc.nil?) &&
12684
+ (opening_loc.nil? == other.opening_loc.nil?) &&
12685
+ (closing_loc.nil? == other.closing_loc.nil?) &&
12686
+ (parameters === other.parameters) &&
12687
+ (body === other.body)
12688
+ end
11731
12689
  end
11732
12690
 
11733
12691
  # Represents the use of the `&&=` operator for assignment to a local variable.
@@ -11803,7 +12761,6 @@ module Prism
11803
12761
  # attr_reader depth: Integer
11804
12762
  attr_reader :depth
11805
12763
 
11806
-
11807
12764
  # def operator: () -> String
11808
12765
  def operator
11809
12766
  operator_loc.slice
@@ -11848,6 +12805,17 @@ module Prism
11848
12805
  def self.type
11849
12806
  :local_variable_and_write_node
11850
12807
  end
12808
+
12809
+ # Implements case-equality for the node. This is effectively == but without
12810
+ # comparing the value of locations. Locations are checked only for presence.
12811
+ def ===(other)
12812
+ other.is_a?(LocalVariableAndWriteNode) &&
12813
+ (name_loc.nil? == other.name_loc.nil?) &&
12814
+ (operator_loc.nil? == other.operator_loc.nil?) &&
12815
+ (value === other.value) &&
12816
+ (name === other.name) &&
12817
+ (depth === other.depth)
12818
+ end
11851
12819
  end
11852
12820
 
11853
12821
  # Represents assigning to a local variable using an operator that isn't `=`.
@@ -11927,7 +12895,6 @@ module Prism
11927
12895
  # attr_reader depth: Integer
11928
12896
  attr_reader :depth
11929
12897
 
11930
-
11931
12898
  # def inspect(NodeInspector inspector) -> String
11932
12899
  def inspect(inspector = NodeInspector.new)
11933
12900
  inspector << inspector.header(self)
@@ -11968,6 +12935,18 @@ module Prism
11968
12935
  def self.type
11969
12936
  :local_variable_operator_write_node
11970
12937
  end
12938
+
12939
+ # Implements case-equality for the node. This is effectively == but without
12940
+ # comparing the value of locations. Locations are checked only for presence.
12941
+ def ===(other)
12942
+ other.is_a?(LocalVariableOperatorWriteNode) &&
12943
+ (name_loc.nil? == other.name_loc.nil?) &&
12944
+ (operator_loc.nil? == other.operator_loc.nil?) &&
12945
+ (value === other.value) &&
12946
+ (name === other.name) &&
12947
+ (operator === other.operator) &&
12948
+ (depth === other.depth)
12949
+ end
11971
12950
  end
11972
12951
 
11973
12952
  # Represents the use of the `||=` operator for assignment to a local variable.
@@ -12043,7 +13022,6 @@ module Prism
12043
13022
  # attr_reader depth: Integer
12044
13023
  attr_reader :depth
12045
13024
 
12046
-
12047
13025
  # def operator: () -> String
12048
13026
  def operator
12049
13027
  operator_loc.slice
@@ -12088,6 +13066,17 @@ module Prism
12088
13066
  def self.type
12089
13067
  :local_variable_or_write_node
12090
13068
  end
13069
+
13070
+ # Implements case-equality for the node. This is effectively == but without
13071
+ # comparing the value of locations. Locations are checked only for presence.
13072
+ def ===(other)
13073
+ other.is_a?(LocalVariableOrWriteNode) &&
13074
+ (name_loc.nil? == other.name_loc.nil?) &&
13075
+ (operator_loc.nil? == other.operator_loc.nil?) &&
13076
+ (value === other.value) &&
13077
+ (name === other.name) &&
13078
+ (depth === other.depth)
13079
+ end
12091
13080
  end
12092
13081
 
12093
13082
  # 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
12161
13150
  # 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).
12162
13151
  attr_reader :depth
12163
13152
 
12164
-
12165
13153
  # def inspect(NodeInspector inspector) -> String
12166
13154
  def inspect(inspector = NodeInspector.new)
12167
13155
  inspector << inspector.header(self)
@@ -12197,6 +13185,14 @@ module Prism
12197
13185
  def self.type
12198
13186
  :local_variable_read_node
12199
13187
  end
13188
+
13189
+ # Implements case-equality for the node. This is effectively == but without
13190
+ # comparing the value of locations. Locations are checked only for presence.
13191
+ def ===(other)
13192
+ other.is_a?(LocalVariableReadNode) &&
13193
+ (name === other.name) &&
13194
+ (depth === other.depth)
13195
+ end
12200
13196
  end
12201
13197
 
12202
13198
  # Represents writing to a local variable in a context that doesn't have an explicit value.
@@ -12252,7 +13248,6 @@ module Prism
12252
13248
  # attr_reader depth: Integer
12253
13249
  attr_reader :depth
12254
13250
 
12255
-
12256
13251
  # def inspect(NodeInspector inspector) -> String
12257
13252
  def inspect(inspector = NodeInspector.new)
12258
13253
  inspector << inspector.header(self)
@@ -12288,6 +13283,14 @@ module Prism
12288
13283
  def self.type
12289
13284
  :local_variable_target_node
12290
13285
  end
13286
+
13287
+ # Implements case-equality for the node. This is effectively == but without
13288
+ # comparing the value of locations. Locations are checked only for presence.
13289
+ def ===(other)
13290
+ other.is_a?(LocalVariableTargetNode) &&
13291
+ (name === other.name) &&
13292
+ (depth === other.depth)
13293
+ end
12291
13294
  end
12292
13295
 
12293
13296
  # Represents writing to a local variable.
@@ -12340,30 +13343,55 @@ module Prism
12340
13343
  { name: name, depth: depth, name_loc: name_loc, value: value, operator_loc: operator_loc, location: location }
12341
13344
  end
12342
13345
 
12343
- # attr_reader name: Symbol
13346
+ # The name of the local variable, which is an [identifier](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#identifiers).
13347
+ #
13348
+ # foo = :bar # name `:foo`
13349
+ #
13350
+ # abc = 123 # name `:abc`
12344
13351
  attr_reader :name
12345
13352
 
12346
- # attr_reader depth: Integer
13353
+ # The number of semantic scopes we have to traverse to find the declaration of this variable.
13354
+ #
13355
+ # foo = 1 # depth 0
13356
+ #
13357
+ # tap { foo = 1 } # depth 1
13358
+ #
13359
+ # 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).
12347
13360
  attr_reader :depth
12348
13361
 
12349
- # attr_reader name_loc: Location
13362
+ # The location of the variable name.
13363
+ #
13364
+ # foo = :bar
13365
+ # ^^^
12350
13366
  def name_loc
12351
13367
  location = @name_loc
12352
13368
  return location if location.is_a?(Location)
12353
13369
  @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
12354
13370
  end
12355
13371
 
12356
- # attr_reader value: Prism::node
13372
+ # 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).
13373
+ #
13374
+ # foo = :bar
13375
+ # ^^^^
13376
+ #
13377
+ # abc = 1234
13378
+ # ^^^^
13379
+ #
13380
+ # 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.
13381
+ #
13382
+ # foo = foo
12357
13383
  attr_reader :value
12358
13384
 
12359
- # attr_reader operator_loc: Location
13385
+ # The location of the `=` operator.
13386
+ #
13387
+ # x = :y
13388
+ # ^
12360
13389
  def operator_loc
12361
13390
  location = @operator_loc
12362
13391
  return location if location.is_a?(Location)
12363
13392
  @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
12364
13393
  end
12365
13394
 
12366
-
12367
13395
  # def operator: () -> String
12368
13396
  def operator
12369
13397
  operator_loc.slice
@@ -12408,6 +13436,17 @@ module Prism
12408
13436
  def self.type
12409
13437
  :local_variable_write_node
12410
13438
  end
13439
+
13440
+ # Implements case-equality for the node. This is effectively == but without
13441
+ # comparing the value of locations. Locations are checked only for presence.
13442
+ def ===(other)
13443
+ other.is_a?(LocalVariableWriteNode) &&
13444
+ (name === other.name) &&
13445
+ (depth === other.depth) &&
13446
+ (name_loc.nil? == other.name_loc.nil?) &&
13447
+ (value === other.value) &&
13448
+ (operator_loc.nil? == other.operator_loc.nil?)
13449
+ end
12411
13450
  end
12412
13451
 
12413
13452
  # 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
12460
13499
  { flags: flags, opening_loc: opening_loc, content_loc: content_loc, closing_loc: closing_loc, unescaped: unescaped, location: location }
12461
13500
  end
12462
13501
 
12463
- # private attr_reader flags: Integer
13502
+ # protected attr_reader flags: Integer
12464
13503
  attr_reader :flags
12465
- private :flags
13504
+ protected :flags
12466
13505
 
12467
13506
  # attr_reader opening_loc: Location
12468
13507
  def opening_loc
@@ -12488,7 +13527,6 @@ module Prism
12488
13527
  # attr_reader unescaped: String
12489
13528
  attr_reader :unescaped
12490
13529
 
12491
-
12492
13530
  # def ignore_case?: () -> bool
12493
13531
  def ignore_case?
12494
13532
  flags.anybits?(RegularExpressionFlags::IGNORE_CASE)
@@ -12598,6 +13636,17 @@ module Prism
12598
13636
  def self.type
12599
13637
  :match_last_line_node
12600
13638
  end
13639
+
13640
+ # Implements case-equality for the node. This is effectively == but without
13641
+ # comparing the value of locations. Locations are checked only for presence.
13642
+ def ===(other)
13643
+ other.is_a?(MatchLastLineNode) &&
13644
+ (flags === other.flags) &&
13645
+ (opening_loc.nil? == other.opening_loc.nil?) &&
13646
+ (content_loc.nil? == other.content_loc.nil?) &&
13647
+ (closing_loc.nil? == other.closing_loc.nil?) &&
13648
+ (unescaped === other.unescaped)
13649
+ end
12601
13650
  end
12602
13651
 
12603
13652
  # Represents the use of the modifier `in` operator.
@@ -12661,7 +13710,6 @@ module Prism
12661
13710
  @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
12662
13711
  end
12663
13712
 
12664
-
12665
13713
  # def operator: () -> String
12666
13714
  def operator
12667
13715
  operator_loc.slice
@@ -12705,6 +13753,15 @@ module Prism
12705
13753
  def self.type
12706
13754
  :match_predicate_node
12707
13755
  end
13756
+
13757
+ # Implements case-equality for the node. This is effectively == but without
13758
+ # comparing the value of locations. Locations are checked only for presence.
13759
+ def ===(other)
13760
+ other.is_a?(MatchPredicateNode) &&
13761
+ (value === other.value) &&
13762
+ (pattern === other.pattern) &&
13763
+ (operator_loc.nil? == other.operator_loc.nil?)
13764
+ end
12708
13765
  end
12709
13766
 
12710
13767
  # Represents the use of the `=>` operator.
@@ -12768,7 +13825,6 @@ module Prism
12768
13825
  @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
12769
13826
  end
12770
13827
 
12771
-
12772
13828
  # def operator: () -> String
12773
13829
  def operator
12774
13830
  operator_loc.slice
@@ -12812,6 +13868,15 @@ module Prism
12812
13868
  def self.type
12813
13869
  :match_required_node
12814
13870
  end
13871
+
13872
+ # Implements case-equality for the node. This is effectively == but without
13873
+ # comparing the value of locations. Locations are checked only for presence.
13874
+ def ===(other)
13875
+ other.is_a?(MatchRequiredNode) &&
13876
+ (value === other.value) &&
13877
+ (pattern === other.pattern) &&
13878
+ (operator_loc.nil? == other.operator_loc.nil?)
13879
+ end
12815
13880
  end
12816
13881
 
12817
13882
  # Represents writing local variables using a regular expression match with named capture groups.
@@ -12867,7 +13932,6 @@ module Prism
12867
13932
  # attr_reader targets: Array[LocalVariableTargetNode]
12868
13933
  attr_reader :targets
12869
13934
 
12870
-
12871
13935
  # def inspect(NodeInspector inspector) -> String
12872
13936
  def inspect(inspector = NodeInspector.new)
12873
13937
  inspector << inspector.header(self)
@@ -12904,6 +13968,15 @@ module Prism
12904
13968
  def self.type
12905
13969
  :match_write_node
12906
13970
  end
13971
+
13972
+ # Implements case-equality for the node. This is effectively == but without
13973
+ # comparing the value of locations. Locations are checked only for presence.
13974
+ def ===(other)
13975
+ other.is_a?(MatchWriteNode) &&
13976
+ (call === other.call) &&
13977
+ (targets.length == other.targets.length) &&
13978
+ targets.zip(other.targets).all? { |left, right| left === right }
13979
+ end
12907
13980
  end
12908
13981
 
12909
13982
  # Represents a node that is missing from the source and results in a syntax error.
@@ -12948,7 +14021,6 @@ module Prism
12948
14021
  { location: location }
12949
14022
  end
12950
14023
 
12951
-
12952
14024
  # def inspect(NodeInspector inspector) -> String
12953
14025
  def inspect(inspector = NodeInspector.new)
12954
14026
  inspector << inspector.header(self)
@@ -12982,6 +14054,12 @@ module Prism
12982
14054
  def self.type
12983
14055
  :missing_node
12984
14056
  end
14057
+
14058
+ # Implements case-equality for the node. This is effectively == but without
14059
+ # comparing the value of locations. Locations are checked only for presence.
14060
+ def ===(other)
14061
+ other.is_a?(MissingNode)
14062
+ end
12985
14063
  end
12986
14064
 
12987
14065
  # Represents a module declaration involving the `module` keyword.
@@ -13064,7 +14142,6 @@ module Prism
13064
14142
  # attr_reader name: Symbol
13065
14143
  attr_reader :name
13066
14144
 
13067
-
13068
14145
  # def module_keyword: () -> String
13069
14146
  def module_keyword
13070
14147
  module_keyword_loc.slice
@@ -13120,6 +14197,19 @@ module Prism
13120
14197
  def self.type
13121
14198
  :module_node
13122
14199
  end
14200
+
14201
+ # Implements case-equality for the node. This is effectively == but without
14202
+ # comparing the value of locations. Locations are checked only for presence.
14203
+ def ===(other)
14204
+ other.is_a?(ModuleNode) &&
14205
+ (locals.length == other.locals.length) &&
14206
+ locals.zip(other.locals).all? { |left, right| left === right } &&
14207
+ (module_keyword_loc.nil? == other.module_keyword_loc.nil?) &&
14208
+ (constant_path === other.constant_path) &&
14209
+ (body === other.body) &&
14210
+ (end_keyword_loc.nil? == other.end_keyword_loc.nil?) &&
14211
+ (name === other.name)
14212
+ end
13123
14213
  end
13124
14214
 
13125
14215
  # Represents a multi-target expression.
@@ -13211,7 +14301,6 @@ module Prism
13211
14301
  end
13212
14302
  end
13213
14303
 
13214
-
13215
14304
  # def lparen: () -> String?
13216
14305
  def lparen
13217
14306
  lparen_loc&.slice
@@ -13265,6 +14354,19 @@ module Prism
13265
14354
  def self.type
13266
14355
  :multi_target_node
13267
14356
  end
14357
+
14358
+ # Implements case-equality for the node. This is effectively == but without
14359
+ # comparing the value of locations. Locations are checked only for presence.
14360
+ def ===(other)
14361
+ other.is_a?(MultiTargetNode) &&
14362
+ (lefts.length == other.lefts.length) &&
14363
+ lefts.zip(other.lefts).all? { |left, right| left === right } &&
14364
+ (rest === other.rest) &&
14365
+ (rights.length == other.rights.length) &&
14366
+ rights.zip(other.rights).all? { |left, right| left === right } &&
14367
+ (lparen_loc.nil? == other.lparen_loc.nil?) &&
14368
+ (rparen_loc.nil? == other.rparen_loc.nil?)
14369
+ end
13268
14370
  end
13269
14371
 
13270
14372
  # Represents a write to a multi-target expression.
@@ -13369,7 +14471,6 @@ module Prism
13369
14471
  # attr_reader value: Prism::node
13370
14472
  attr_reader :value
13371
14473
 
13372
-
13373
14474
  # def lparen: () -> String?
13374
14475
  def lparen
13375
14476
  lparen_loc&.slice
@@ -13431,6 +14532,21 @@ module Prism
13431
14532
  def self.type
13432
14533
  :multi_write_node
13433
14534
  end
14535
+
14536
+ # Implements case-equality for the node. This is effectively == but without
14537
+ # comparing the value of locations. Locations are checked only for presence.
14538
+ def ===(other)
14539
+ other.is_a?(MultiWriteNode) &&
14540
+ (lefts.length == other.lefts.length) &&
14541
+ lefts.zip(other.lefts).all? { |left, right| left === right } &&
14542
+ (rest === other.rest) &&
14543
+ (rights.length == other.rights.length) &&
14544
+ rights.zip(other.rights).all? { |left, right| left === right } &&
14545
+ (lparen_loc.nil? == other.lparen_loc.nil?) &&
14546
+ (rparen_loc.nil? == other.rparen_loc.nil?) &&
14547
+ (operator_loc.nil? == other.operator_loc.nil?) &&
14548
+ (value === other.value)
14549
+ end
13434
14550
  end
13435
14551
 
13436
14552
  # Represents the use of the `next` keyword.
@@ -13492,7 +14608,6 @@ module Prism
13492
14608
  @keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
13493
14609
  end
13494
14610
 
13495
-
13496
14611
  # def keyword: () -> String
13497
14612
  def keyword
13498
14613
  keyword_loc.slice
@@ -13538,6 +14653,14 @@ module Prism
13538
14653
  def self.type
13539
14654
  :next_node
13540
14655
  end
14656
+
14657
+ # Implements case-equality for the node. This is effectively == but without
14658
+ # comparing the value of locations. Locations are checked only for presence.
14659
+ def ===(other)
14660
+ other.is_a?(NextNode) &&
14661
+ (arguments === other.arguments) &&
14662
+ (keyword_loc.nil? == other.keyword_loc.nil?)
14663
+ end
13541
14664
  end
13542
14665
 
13543
14666
  # Represents the use of the `nil` keyword.
@@ -13585,7 +14708,6 @@ module Prism
13585
14708
  { location: location }
13586
14709
  end
13587
14710
 
13588
-
13589
14711
  # def inspect(NodeInspector inspector) -> String
13590
14712
  def inspect(inspector = NodeInspector.new)
13591
14713
  inspector << inspector.header(self)
@@ -13619,6 +14741,12 @@ module Prism
13619
14741
  def self.type
13620
14742
  :nil_node
13621
14743
  end
14744
+
14745
+ # Implements case-equality for the node. This is effectively == but without
14746
+ # comparing the value of locations. Locations are checked only for presence.
14747
+ def ===(other)
14748
+ other.is_a?(NilNode)
14749
+ end
13622
14750
  end
13623
14751
 
13624
14752
  # Represents the use of `**nil` inside method arguments.
@@ -13683,7 +14811,6 @@ module Prism
13683
14811
  @keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
13684
14812
  end
13685
14813
 
13686
-
13687
14814
  # def operator: () -> String
13688
14815
  def operator
13689
14816
  operator_loc.slice
@@ -13729,6 +14856,14 @@ module Prism
13729
14856
  def self.type
13730
14857
  :no_keywords_parameter_node
13731
14858
  end
14859
+
14860
+ # Implements case-equality for the node. This is effectively == but without
14861
+ # comparing the value of locations. Locations are checked only for presence.
14862
+ def ===(other)
14863
+ other.is_a?(NoKeywordsParameterNode) &&
14864
+ (operator_loc.nil? == other.operator_loc.nil?) &&
14865
+ (keyword_loc.nil? == other.keyword_loc.nil?)
14866
+ end
13732
14867
  end
13733
14868
 
13734
14869
  # Represents an implicit set of parameters through the use of numbered parameters within a block or lambda.
@@ -13780,7 +14915,6 @@ module Prism
13780
14915
  # attr_reader maximum: Integer
13781
14916
  attr_reader :maximum
13782
14917
 
13783
-
13784
14918
  # def inspect(NodeInspector inspector) -> String
13785
14919
  def inspect(inspector = NodeInspector.new)
13786
14920
  inspector << inspector.header(self)
@@ -13815,6 +14949,13 @@ module Prism
13815
14949
  def self.type
13816
14950
  :numbered_parameters_node
13817
14951
  end
14952
+
14953
+ # Implements case-equality for the node. This is effectively == but without
14954
+ # comparing the value of locations. Locations are checked only for presence.
14955
+ def ===(other)
14956
+ other.is_a?(NumberedParametersNode) &&
14957
+ (maximum === other.maximum)
14958
+ end
13818
14959
  end
13819
14960
 
13820
14961
  # Represents reading a numbered reference to a capture in the previous match.
@@ -13872,7 +15013,6 @@ module Prism
13872
15013
  # $4294967296 # number `0`
13873
15014
  attr_reader :number
13874
15015
 
13875
-
13876
15016
  # def inspect(NodeInspector inspector) -> String
13877
15017
  def inspect(inspector = NodeInspector.new)
13878
15018
  inspector << inspector.header(self)
@@ -13907,6 +15047,13 @@ module Prism
13907
15047
  def self.type
13908
15048
  :numbered_reference_read_node
13909
15049
  end
15050
+
15051
+ # Implements case-equality for the node. This is effectively == but without
15052
+ # comparing the value of locations. Locations are checked only for presence.
15053
+ def ===(other)
15054
+ other.is_a?(NumberedReferenceReadNode) &&
15055
+ (number === other.number)
15056
+ end
13910
15057
  end
13911
15058
 
13912
15059
  # Represents an optional keyword parameter to a method, block, or lambda definition.
@@ -13959,9 +15106,9 @@ module Prism
13959
15106
  { flags: flags, name: name, name_loc: name_loc, value: value, location: location }
13960
15107
  end
13961
15108
 
13962
- # private attr_reader flags: Integer
15109
+ # protected attr_reader flags: Integer
13963
15110
  attr_reader :flags
13964
- private :flags
15111
+ protected :flags
13965
15112
 
13966
15113
  # attr_reader name: Symbol
13967
15114
  attr_reader :name
@@ -13976,7 +15123,6 @@ module Prism
13976
15123
  # attr_reader value: Prism::node
13977
15124
  attr_reader :value
13978
15125
 
13979
-
13980
15126
  # def repeated_parameter?: () -> bool
13981
15127
  def repeated_parameter?
13982
15128
  flags.anybits?(ParameterFlags::REPEATED_PARAMETER)
@@ -14021,6 +15167,16 @@ module Prism
14021
15167
  def self.type
14022
15168
  :optional_keyword_parameter_node
14023
15169
  end
15170
+
15171
+ # Implements case-equality for the node. This is effectively == but without
15172
+ # comparing the value of locations. Locations are checked only for presence.
15173
+ def ===(other)
15174
+ other.is_a?(OptionalKeywordParameterNode) &&
15175
+ (flags === other.flags) &&
15176
+ (name === other.name) &&
15177
+ (name_loc.nil? == other.name_loc.nil?) &&
15178
+ (value === other.value)
15179
+ end
14024
15180
  end
14025
15181
 
14026
15182
  # Represents an optional parameter to a method, block, or lambda definition.
@@ -14074,9 +15230,9 @@ module Prism
14074
15230
  { flags: flags, name: name, name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
14075
15231
  end
14076
15232
 
14077
- # private attr_reader flags: Integer
15233
+ # protected attr_reader flags: Integer
14078
15234
  attr_reader :flags
14079
- private :flags
15235
+ protected :flags
14080
15236
 
14081
15237
  # attr_reader name: Symbol
14082
15238
  attr_reader :name
@@ -14098,7 +15254,6 @@ module Prism
14098
15254
  # attr_reader value: Prism::node
14099
15255
  attr_reader :value
14100
15256
 
14101
-
14102
15257
  # def repeated_parameter?: () -> bool
14103
15258
  def repeated_parameter?
14104
15259
  flags.anybits?(ParameterFlags::REPEATED_PARAMETER)
@@ -14149,6 +15304,17 @@ module Prism
14149
15304
  def self.type
14150
15305
  :optional_parameter_node
14151
15306
  end
15307
+
15308
+ # Implements case-equality for the node. This is effectively == but without
15309
+ # comparing the value of locations. Locations are checked only for presence.
15310
+ def ===(other)
15311
+ other.is_a?(OptionalParameterNode) &&
15312
+ (flags === other.flags) &&
15313
+ (name === other.name) &&
15314
+ (name_loc.nil? == other.name_loc.nil?) &&
15315
+ (operator_loc.nil? == other.operator_loc.nil?) &&
15316
+ (value === other.value)
15317
+ end
14152
15318
  end
14153
15319
 
14154
15320
  # Represents the use of the `||` operator or the `or` keyword.
@@ -14227,7 +15393,6 @@ module Prism
14227
15393
  @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
14228
15394
  end
14229
15395
 
14230
-
14231
15396
  # def operator: () -> String
14232
15397
  def operator
14233
15398
  operator_loc.slice
@@ -14271,6 +15436,15 @@ module Prism
14271
15436
  def self.type
14272
15437
  :or_node
14273
15438
  end
15439
+
15440
+ # Implements case-equality for the node. This is effectively == but without
15441
+ # comparing the value of locations. Locations are checked only for presence.
15442
+ def ===(other)
15443
+ other.is_a?(OrNode) &&
15444
+ (left === other.left) &&
15445
+ (right === other.right) &&
15446
+ (operator_loc.nil? == other.operator_loc.nil?)
15447
+ end
14274
15448
  end
14275
15449
 
14276
15450
  # Represents the list of parameters on a method, block, or lambda definition.
@@ -14355,7 +15529,6 @@ module Prism
14355
15529
  # attr_reader block: BlockParameterNode?
14356
15530
  attr_reader :block
14357
15531
 
14358
-
14359
15532
  # def inspect(NodeInspector inspector) -> String
14360
15533
  def inspect(inspector = NodeInspector.new)
14361
15534
  inspector << inspector.header(self)
@@ -14411,6 +15584,23 @@ module Prism
14411
15584
  def self.type
14412
15585
  :parameters_node
14413
15586
  end
15587
+
15588
+ # Implements case-equality for the node. This is effectively == but without
15589
+ # comparing the value of locations. Locations are checked only for presence.
15590
+ def ===(other)
15591
+ other.is_a?(ParametersNode) &&
15592
+ (requireds.length == other.requireds.length) &&
15593
+ requireds.zip(other.requireds).all? { |left, right| left === right } &&
15594
+ (optionals.length == other.optionals.length) &&
15595
+ optionals.zip(other.optionals).all? { |left, right| left === right } &&
15596
+ (rest === other.rest) &&
15597
+ (posts.length == other.posts.length) &&
15598
+ posts.zip(other.posts).all? { |left, right| left === right } &&
15599
+ (keywords.length == other.keywords.length) &&
15600
+ keywords.zip(other.keywords).all? { |left, right| left === right } &&
15601
+ (keyword_rest === other.keyword_rest) &&
15602
+ (block === other.block)
15603
+ end
14414
15604
  end
14415
15605
 
14416
15606
  # Represents a parenthesized expression
@@ -14484,7 +15674,6 @@ module Prism
14484
15674
  @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
14485
15675
  end
14486
15676
 
14487
-
14488
15677
  # def opening: () -> String
14489
15678
  def opening
14490
15679
  opening_loc.slice
@@ -14536,6 +15725,15 @@ module Prism
14536
15725
  def self.type
14537
15726
  :parentheses_node
14538
15727
  end
15728
+
15729
+ # Implements case-equality for the node. This is effectively == but without
15730
+ # comparing the value of locations. Locations are checked only for presence.
15731
+ def ===(other)
15732
+ other.is_a?(ParenthesesNode) &&
15733
+ (body === other.body) &&
15734
+ (opening_loc.nil? == other.opening_loc.nil?) &&
15735
+ (closing_loc.nil? == other.closing_loc.nil?)
15736
+ end
14539
15737
  end
14540
15738
 
14541
15739
  # Represents the use of the `^` operator for pinning an expression in a pattern matching expression.
@@ -14611,7 +15809,6 @@ module Prism
14611
15809
  @rparen_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
14612
15810
  end
14613
15811
 
14614
-
14615
15812
  # def operator: () -> String
14616
15813
  def operator
14617
15814
  operator_loc.slice
@@ -14665,6 +15862,16 @@ module Prism
14665
15862
  def self.type
14666
15863
  :pinned_expression_node
14667
15864
  end
15865
+
15866
+ # Implements case-equality for the node. This is effectively == but without
15867
+ # comparing the value of locations. Locations are checked only for presence.
15868
+ def ===(other)
15869
+ other.is_a?(PinnedExpressionNode) &&
15870
+ (expression === other.expression) &&
15871
+ (operator_loc.nil? == other.operator_loc.nil?) &&
15872
+ (lparen_loc.nil? == other.lparen_loc.nil?) &&
15873
+ (rparen_loc.nil? == other.rparen_loc.nil?)
15874
+ end
14668
15875
  end
14669
15876
 
14670
15877
  # Represents the use of the `^` operator for pinning a variable in a pattern matching expression.
@@ -14724,7 +15931,6 @@ module Prism
14724
15931
  @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
14725
15932
  end
14726
15933
 
14727
-
14728
15934
  # def operator: () -> String
14729
15935
  def operator
14730
15936
  operator_loc.slice
@@ -14766,6 +15972,14 @@ module Prism
14766
15972
  def self.type
14767
15973
  :pinned_variable_node
14768
15974
  end
15975
+
15976
+ # Implements case-equality for the node. This is effectively == but without
15977
+ # comparing the value of locations. Locations are checked only for presence.
15978
+ def ===(other)
15979
+ other.is_a?(PinnedVariableNode) &&
15980
+ (variable === other.variable) &&
15981
+ (operator_loc.nil? == other.operator_loc.nil?)
15982
+ end
14769
15983
  end
14770
15984
 
14771
15985
  # Represents the use of the `END` keyword.
@@ -14843,7 +16057,6 @@ module Prism
14843
16057
  @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
14844
16058
  end
14845
16059
 
14846
-
14847
16060
  # def keyword: () -> String
14848
16061
  def keyword
14849
16062
  keyword_loc.slice
@@ -14901,6 +16114,16 @@ module Prism
14901
16114
  def self.type
14902
16115
  :post_execution_node
14903
16116
  end
16117
+
16118
+ # Implements case-equality for the node. This is effectively == but without
16119
+ # comparing the value of locations. Locations are checked only for presence.
16120
+ def ===(other)
16121
+ other.is_a?(PostExecutionNode) &&
16122
+ (statements === other.statements) &&
16123
+ (keyword_loc.nil? == other.keyword_loc.nil?) &&
16124
+ (opening_loc.nil? == other.opening_loc.nil?) &&
16125
+ (closing_loc.nil? == other.closing_loc.nil?)
16126
+ end
14904
16127
  end
14905
16128
 
14906
16129
  # Represents the use of the `BEGIN` keyword.
@@ -14978,7 +16201,6 @@ module Prism
14978
16201
  @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
14979
16202
  end
14980
16203
 
14981
-
14982
16204
  # def keyword: () -> String
14983
16205
  def keyword
14984
16206
  keyword_loc.slice
@@ -15036,6 +16258,16 @@ module Prism
15036
16258
  def self.type
15037
16259
  :pre_execution_node
15038
16260
  end
16261
+
16262
+ # Implements case-equality for the node. This is effectively == but without
16263
+ # comparing the value of locations. Locations are checked only for presence.
16264
+ def ===(other)
16265
+ other.is_a?(PreExecutionNode) &&
16266
+ (statements === other.statements) &&
16267
+ (keyword_loc.nil? == other.keyword_loc.nil?) &&
16268
+ (opening_loc.nil? == other.opening_loc.nil?) &&
16269
+ (closing_loc.nil? == other.closing_loc.nil?)
16270
+ end
15039
16271
  end
15040
16272
 
15041
16273
  # The top level node of any parse tree.
@@ -15088,7 +16320,6 @@ module Prism
15088
16320
  # attr_reader statements: StatementsNode
15089
16321
  attr_reader :statements
15090
16322
 
15091
-
15092
16323
  # def inspect(NodeInspector inspector) -> String
15093
16324
  def inspect(inspector = NodeInspector.new)
15094
16325
  inspector << inspector.header(self)
@@ -15125,6 +16356,15 @@ module Prism
15125
16356
  def self.type
15126
16357
  :program_node
15127
16358
  end
16359
+
16360
+ # Implements case-equality for the node. This is effectively == but without
16361
+ # comparing the value of locations. Locations are checked only for presence.
16362
+ def ===(other)
16363
+ other.is_a?(ProgramNode) &&
16364
+ (locals.length == other.locals.length) &&
16365
+ locals.zip(other.locals).all? { |left, right| left === right } &&
16366
+ (statements === other.statements)
16367
+ end
15128
16368
  end
15129
16369
 
15130
16370
  # Represents the use of the `..` or `...` operators.
@@ -15182,9 +16422,9 @@ module Prism
15182
16422
  { flags: flags, left: left, right: right, operator_loc: operator_loc, location: location }
15183
16423
  end
15184
16424
 
15185
- # private attr_reader flags: Integer
16425
+ # protected attr_reader flags: Integer
15186
16426
  attr_reader :flags
15187
- private :flags
16427
+ protected :flags
15188
16428
 
15189
16429
  # 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).
15190
16430
  #
@@ -15212,7 +16452,6 @@ module Prism
15212
16452
  @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
15213
16453
  end
15214
16454
 
15215
-
15216
16455
  # def exclude_end?: () -> bool
15217
16456
  def exclude_end?
15218
16457
  flags.anybits?(RangeFlags::EXCLUDE_END)
@@ -15271,6 +16510,16 @@ module Prism
15271
16510
  def self.type
15272
16511
  :range_node
15273
16512
  end
16513
+
16514
+ # Implements case-equality for the node. This is effectively == but without
16515
+ # comparing the value of locations. Locations are checked only for presence.
16516
+ def ===(other)
16517
+ other.is_a?(RangeNode) &&
16518
+ (flags === other.flags) &&
16519
+ (left === other.left) &&
16520
+ (right === other.right) &&
16521
+ (operator_loc.nil? == other.operator_loc.nil?)
16522
+ end
15274
16523
  end
15275
16524
 
15276
16525
  # Represents a rational number literal.
@@ -15322,7 +16571,6 @@ module Prism
15322
16571
  # attr_reader numeric: Prism::node
15323
16572
  attr_reader :numeric
15324
16573
 
15325
-
15326
16574
  # def inspect(NodeInspector inspector) -> String
15327
16575
  def inspect(inspector = NodeInspector.new)
15328
16576
  inspector << inspector.header(self)
@@ -15358,6 +16606,13 @@ module Prism
15358
16606
  def self.type
15359
16607
  :rational_node
15360
16608
  end
16609
+
16610
+ # Implements case-equality for the node. This is effectively == but without
16611
+ # comparing the value of locations. Locations are checked only for presence.
16612
+ def ===(other)
16613
+ other.is_a?(RationalNode) &&
16614
+ (numeric === other.numeric)
16615
+ end
15361
16616
  end
15362
16617
 
15363
16618
  # Represents the use of the `redo` keyword.
@@ -15405,7 +16660,6 @@ module Prism
15405
16660
  { location: location }
15406
16661
  end
15407
16662
 
15408
-
15409
16663
  # def inspect(NodeInspector inspector) -> String
15410
16664
  def inspect(inspector = NodeInspector.new)
15411
16665
  inspector << inspector.header(self)
@@ -15439,6 +16693,12 @@ module Prism
15439
16693
  def self.type
15440
16694
  :redo_node
15441
16695
  end
16696
+
16697
+ # Implements case-equality for the node. This is effectively == but without
16698
+ # comparing the value of locations. Locations are checked only for presence.
16699
+ def ===(other)
16700
+ other.is_a?(RedoNode)
16701
+ end
15442
16702
  end
15443
16703
 
15444
16704
  # Represents a regular expression literal with no interpolation.
@@ -15491,9 +16751,9 @@ module Prism
15491
16751
  { flags: flags, opening_loc: opening_loc, content_loc: content_loc, closing_loc: closing_loc, unescaped: unescaped, location: location }
15492
16752
  end
15493
16753
 
15494
- # private attr_reader flags: Integer
16754
+ # protected attr_reader flags: Integer
15495
16755
  attr_reader :flags
15496
- private :flags
16756
+ protected :flags
15497
16757
 
15498
16758
  # attr_reader opening_loc: Location
15499
16759
  def opening_loc
@@ -15519,7 +16779,6 @@ module Prism
15519
16779
  # attr_reader unescaped: String
15520
16780
  attr_reader :unescaped
15521
16781
 
15522
-
15523
16782
  # def ignore_case?: () -> bool
15524
16783
  def ignore_case?
15525
16784
  flags.anybits?(RegularExpressionFlags::IGNORE_CASE)
@@ -15629,6 +16888,17 @@ module Prism
15629
16888
  def self.type
15630
16889
  :regular_expression_node
15631
16890
  end
16891
+
16892
+ # Implements case-equality for the node. This is effectively == but without
16893
+ # comparing the value of locations. Locations are checked only for presence.
16894
+ def ===(other)
16895
+ other.is_a?(RegularExpressionNode) &&
16896
+ (flags === other.flags) &&
16897
+ (opening_loc.nil? == other.opening_loc.nil?) &&
16898
+ (content_loc.nil? == other.content_loc.nil?) &&
16899
+ (closing_loc.nil? == other.closing_loc.nil?) &&
16900
+ (unescaped === other.unescaped)
16901
+ end
15632
16902
  end
15633
16903
 
15634
16904
  # Represents a required keyword parameter to a method, block, or lambda definition.
@@ -15680,9 +16950,9 @@ module Prism
15680
16950
  { flags: flags, name: name, name_loc: name_loc, location: location }
15681
16951
  end
15682
16952
 
15683
- # private attr_reader flags: Integer
16953
+ # protected attr_reader flags: Integer
15684
16954
  attr_reader :flags
15685
- private :flags
16955
+ protected :flags
15686
16956
 
15687
16957
  # attr_reader name: Symbol
15688
16958
  attr_reader :name
@@ -15694,7 +16964,6 @@ module Prism
15694
16964
  @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
15695
16965
  end
15696
16966
 
15697
-
15698
16967
  # def repeated_parameter?: () -> bool
15699
16968
  def repeated_parameter?
15700
16969
  flags.anybits?(ParameterFlags::REPEATED_PARAMETER)
@@ -15737,6 +17006,15 @@ module Prism
15737
17006
  def self.type
15738
17007
  :required_keyword_parameter_node
15739
17008
  end
17009
+
17010
+ # Implements case-equality for the node. This is effectively == but without
17011
+ # comparing the value of locations. Locations are checked only for presence.
17012
+ def ===(other)
17013
+ other.is_a?(RequiredKeywordParameterNode) &&
17014
+ (flags === other.flags) &&
17015
+ (name === other.name) &&
17016
+ (name_loc.nil? == other.name_loc.nil?)
17017
+ end
15740
17018
  end
15741
17019
 
15742
17020
  # Represents a required parameter to a method, block, or lambda definition.
@@ -15787,14 +17065,13 @@ module Prism
15787
17065
  { flags: flags, name: name, location: location }
15788
17066
  end
15789
17067
 
15790
- # private attr_reader flags: Integer
17068
+ # protected attr_reader flags: Integer
15791
17069
  attr_reader :flags
15792
- private :flags
17070
+ protected :flags
15793
17071
 
15794
17072
  # attr_reader name: Symbol
15795
17073
  attr_reader :name
15796
17074
 
15797
-
15798
17075
  # def repeated_parameter?: () -> bool
15799
17076
  def repeated_parameter?
15800
17077
  flags.anybits?(ParameterFlags::REPEATED_PARAMETER)
@@ -15836,6 +17113,14 @@ module Prism
15836
17113
  def self.type
15837
17114
  :required_parameter_node
15838
17115
  end
17116
+
17117
+ # Implements case-equality for the node. This is effectively == but without
17118
+ # comparing the value of locations. Locations are checked only for presence.
17119
+ def ===(other)
17120
+ other.is_a?(RequiredParameterNode) &&
17121
+ (flags === other.flags) &&
17122
+ (name === other.name)
17123
+ end
15839
17124
  end
15840
17125
 
15841
17126
  # Represents an expression modified with a rescue.
@@ -15903,7 +17188,6 @@ module Prism
15903
17188
  # attr_reader rescue_expression: Prism::node
15904
17189
  attr_reader :rescue_expression
15905
17190
 
15906
-
15907
17191
  # def keyword: () -> String
15908
17192
  def keyword
15909
17193
  keyword_loc.slice
@@ -15947,6 +17231,15 @@ module Prism
15947
17231
  def self.type
15948
17232
  :rescue_modifier_node
15949
17233
  end
17234
+
17235
+ # Implements case-equality for the node. This is effectively == but without
17236
+ # comparing the value of locations. Locations are checked only for presence.
17237
+ def ===(other)
17238
+ other.is_a?(RescueModifierNode) &&
17239
+ (expression === other.expression) &&
17240
+ (keyword_loc.nil? == other.keyword_loc.nil?) &&
17241
+ (rescue_expression === other.rescue_expression)
17242
+ end
15950
17243
  end
15951
17244
 
15952
17245
  # Represents a rescue statement.
@@ -16042,7 +17335,6 @@ module Prism
16042
17335
  # attr_reader consequent: RescueNode?
16043
17336
  attr_reader :consequent
16044
17337
 
16045
-
16046
17338
  # def keyword: () -> String
16047
17339
  def keyword
16048
17340
  keyword_loc.slice
@@ -16107,6 +17399,19 @@ module Prism
16107
17399
  def self.type
16108
17400
  :rescue_node
16109
17401
  end
17402
+
17403
+ # Implements case-equality for the node. This is effectively == but without
17404
+ # comparing the value of locations. Locations are checked only for presence.
17405
+ def ===(other)
17406
+ other.is_a?(RescueNode) &&
17407
+ (keyword_loc.nil? == other.keyword_loc.nil?) &&
17408
+ (exceptions.length == other.exceptions.length) &&
17409
+ exceptions.zip(other.exceptions).all? { |left, right| left === right } &&
17410
+ (operator_loc.nil? == other.operator_loc.nil?) &&
17411
+ (reference === other.reference) &&
17412
+ (statements === other.statements) &&
17413
+ (consequent === other.consequent)
17414
+ end
16110
17415
  end
16111
17416
 
16112
17417
  # Represents a rest parameter to a method, block, or lambda definition.
@@ -16159,9 +17464,9 @@ module Prism
16159
17464
  { flags: flags, name: name, name_loc: name_loc, operator_loc: operator_loc, location: location }
16160
17465
  end
16161
17466
 
16162
- # private attr_reader flags: Integer
17467
+ # protected attr_reader flags: Integer
16163
17468
  attr_reader :flags
16164
- private :flags
17469
+ protected :flags
16165
17470
 
16166
17471
  # attr_reader name: Symbol?
16167
17472
  attr_reader :name
@@ -16186,7 +17491,6 @@ module Prism
16186
17491
  @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
16187
17492
  end
16188
17493
 
16189
-
16190
17494
  # def repeated_parameter?: () -> bool
16191
17495
  def repeated_parameter?
16192
17496
  flags.anybits?(ParameterFlags::REPEATED_PARAMETER)
@@ -16239,6 +17543,16 @@ module Prism
16239
17543
  def self.type
16240
17544
  :rest_parameter_node
16241
17545
  end
17546
+
17547
+ # Implements case-equality for the node. This is effectively == but without
17548
+ # comparing the value of locations. Locations are checked only for presence.
17549
+ def ===(other)
17550
+ other.is_a?(RestParameterNode) &&
17551
+ (flags === other.flags) &&
17552
+ (name === other.name) &&
17553
+ (name_loc.nil? == other.name_loc.nil?) &&
17554
+ (operator_loc.nil? == other.operator_loc.nil?)
17555
+ end
16242
17556
  end
16243
17557
 
16244
17558
  # Represents the use of the `retry` keyword.
@@ -16286,7 +17600,6 @@ module Prism
16286
17600
  { location: location }
16287
17601
  end
16288
17602
 
16289
-
16290
17603
  # def inspect(NodeInspector inspector) -> String
16291
17604
  def inspect(inspector = NodeInspector.new)
16292
17605
  inspector << inspector.header(self)
@@ -16320,6 +17633,12 @@ module Prism
16320
17633
  def self.type
16321
17634
  :retry_node
16322
17635
  end
17636
+
17637
+ # Implements case-equality for the node. This is effectively == but without
17638
+ # comparing the value of locations. Locations are checked only for presence.
17639
+ def ===(other)
17640
+ other.is_a?(RetryNode)
17641
+ end
16323
17642
  end
16324
17643
 
16325
17644
  # Represents the use of the `return` keyword.
@@ -16381,7 +17700,6 @@ module Prism
16381
17700
  # attr_reader arguments: ArgumentsNode?
16382
17701
  attr_reader :arguments
16383
17702
 
16384
-
16385
17703
  # def keyword: () -> String
16386
17704
  def keyword
16387
17705
  keyword_loc.slice
@@ -16427,6 +17745,14 @@ module Prism
16427
17745
  def self.type
16428
17746
  :return_node
16429
17747
  end
17748
+
17749
+ # Implements case-equality for the node. This is effectively == but without
17750
+ # comparing the value of locations. Locations are checked only for presence.
17751
+ def ===(other)
17752
+ other.is_a?(ReturnNode) &&
17753
+ (keyword_loc.nil? == other.keyword_loc.nil?) &&
17754
+ (arguments === other.arguments)
17755
+ end
16430
17756
  end
16431
17757
 
16432
17758
  # Represents the `self` keyword.
@@ -16474,7 +17800,6 @@ module Prism
16474
17800
  { location: location }
16475
17801
  end
16476
17802
 
16477
-
16478
17803
  # def inspect(NodeInspector inspector) -> String
16479
17804
  def inspect(inspector = NodeInspector.new)
16480
17805
  inspector << inspector.header(self)
@@ -16508,6 +17833,12 @@ module Prism
16508
17833
  def self.type
16509
17834
  :self_node
16510
17835
  end
17836
+
17837
+ # Implements case-equality for the node. This is effectively == but without
17838
+ # comparing the value of locations. Locations are checked only for presence.
17839
+ def ===(other)
17840
+ other.is_a?(SelfNode)
17841
+ end
16511
17842
  end
16512
17843
 
16513
17844
  # 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
16558
17889
  { flags: flags, write: write, location: location }
16559
17890
  end
16560
17891
 
16561
- # private attr_reader flags: Integer
17892
+ # protected attr_reader flags: Integer
16562
17893
  attr_reader :flags
16563
- private :flags
17894
+ protected :flags
16564
17895
 
16565
17896
  # The constant write that should be modified with the shareability state.
16566
17897
  attr_reader :write
16567
17898
 
16568
-
16569
17899
  # def literal?: () -> bool
16570
17900
  def literal?
16571
17901
  flags.anybits?(ShareableConstantNodeFlags::LITERAL)
@@ -16618,6 +17948,14 @@ module Prism
16618
17948
  def self.type
16619
17949
  :shareable_constant_node
16620
17950
  end
17951
+
17952
+ # Implements case-equality for the node. This is effectively == but without
17953
+ # comparing the value of locations. Locations are checked only for presence.
17954
+ def ===(other)
17955
+ other.is_a?(ShareableConstantNode) &&
17956
+ (flags === other.flags) &&
17957
+ (write === other.write)
17958
+ end
16621
17959
  end
16622
17960
 
16623
17961
  # Represents a singleton class declaration involving the `class` keyword.
@@ -16704,7 +18042,6 @@ module Prism
16704
18042
  @end_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
16705
18043
  end
16706
18044
 
16707
-
16708
18045
  # def class_keyword: () -> String
16709
18046
  def class_keyword
16710
18047
  class_keyword_loc.slice
@@ -16765,6 +18102,19 @@ module Prism
16765
18102
  def self.type
16766
18103
  :singleton_class_node
16767
18104
  end
18105
+
18106
+ # Implements case-equality for the node. This is effectively == but without
18107
+ # comparing the value of locations. Locations are checked only for presence.
18108
+ def ===(other)
18109
+ other.is_a?(SingletonClassNode) &&
18110
+ (locals.length == other.locals.length) &&
18111
+ locals.zip(other.locals).all? { |left, right| left === right } &&
18112
+ (class_keyword_loc.nil? == other.class_keyword_loc.nil?) &&
18113
+ (operator_loc.nil? == other.operator_loc.nil?) &&
18114
+ (expression === other.expression) &&
18115
+ (body === other.body) &&
18116
+ (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
18117
+ end
16768
18118
  end
16769
18119
 
16770
18120
  # Represents the use of the `__ENCODING__` keyword.
@@ -16812,7 +18162,6 @@ module Prism
16812
18162
  { location: location }
16813
18163
  end
16814
18164
 
16815
-
16816
18165
  # def inspect(NodeInspector inspector) -> String
16817
18166
  def inspect(inspector = NodeInspector.new)
16818
18167
  inspector << inspector.header(self)
@@ -16846,6 +18195,12 @@ module Prism
16846
18195
  def self.type
16847
18196
  :source_encoding_node
16848
18197
  end
18198
+
18199
+ # Implements case-equality for the node. This is effectively == but without
18200
+ # comparing the value of locations. Locations are checked only for presence.
18201
+ def ===(other)
18202
+ other.is_a?(SourceEncodingNode)
18203
+ end
16849
18204
  end
16850
18205
 
16851
18206
  # Represents the use of the `__FILE__` keyword.
@@ -16895,14 +18250,13 @@ module Prism
16895
18250
  { flags: flags, filepath: filepath, location: location }
16896
18251
  end
16897
18252
 
16898
- # private attr_reader flags: Integer
18253
+ # protected attr_reader flags: Integer
16899
18254
  attr_reader :flags
16900
- private :flags
18255
+ protected :flags
16901
18256
 
16902
- # attr_reader filepath: String
18257
+ # Represents the file path being parsed. This corresponds directly to the `filepath` option given to the various `Prism::parse*` APIs.
16903
18258
  attr_reader :filepath
16904
18259
 
16905
-
16906
18260
  # def forced_utf8_encoding?: () -> bool
16907
18261
  def forced_utf8_encoding?
16908
18262
  flags.anybits?(StringFlags::FORCED_UTF8_ENCODING)
@@ -16959,6 +18313,14 @@ module Prism
16959
18313
  def self.type
16960
18314
  :source_file_node
16961
18315
  end
18316
+
18317
+ # Implements case-equality for the node. This is effectively == but without
18318
+ # comparing the value of locations. Locations are checked only for presence.
18319
+ def ===(other)
18320
+ other.is_a?(SourceFileNode) &&
18321
+ (flags === other.flags) &&
18322
+ (filepath === other.filepath)
18323
+ end
16962
18324
  end
16963
18325
 
16964
18326
  # Represents the use of the `__LINE__` keyword.
@@ -17006,7 +18368,6 @@ module Prism
17006
18368
  { location: location }
17007
18369
  end
17008
18370
 
17009
-
17010
18371
  # def inspect(NodeInspector inspector) -> String
17011
18372
  def inspect(inspector = NodeInspector.new)
17012
18373
  inspector << inspector.header(self)
@@ -17040,6 +18401,12 @@ module Prism
17040
18401
  def self.type
17041
18402
  :source_line_node
17042
18403
  end
18404
+
18405
+ # Implements case-equality for the node. This is effectively == but without
18406
+ # comparing the value of locations. Locations are checked only for presence.
18407
+ def ===(other)
18408
+ other.is_a?(SourceLineNode)
18409
+ end
17043
18410
  end
17044
18411
 
17045
18412
  # Represents the use of the splat operator.
@@ -17101,7 +18468,6 @@ module Prism
17101
18468
  # attr_reader expression: Prism::node?
17102
18469
  attr_reader :expression
17103
18470
 
17104
-
17105
18471
  # def operator: () -> String
17106
18472
  def operator
17107
18473
  operator_loc.slice
@@ -17147,6 +18513,14 @@ module Prism
17147
18513
  def self.type
17148
18514
  :splat_node
17149
18515
  end
18516
+
18517
+ # Implements case-equality for the node. This is effectively == but without
18518
+ # comparing the value of locations. Locations are checked only for presence.
18519
+ def ===(other)
18520
+ other.is_a?(SplatNode) &&
18521
+ (operator_loc.nil? == other.operator_loc.nil?) &&
18522
+ (expression === other.expression)
18523
+ end
17150
18524
  end
17151
18525
 
17152
18526
  # Represents a set of statements contained within some scope.
@@ -17198,7 +18572,6 @@ module Prism
17198
18572
  # attr_reader body: Array[Prism::node]
17199
18573
  attr_reader :body
17200
18574
 
17201
-
17202
18575
  # def inspect(NodeInspector inspector) -> String
17203
18576
  def inspect(inspector = NodeInspector.new)
17204
18577
  inspector << inspector.header(self)
@@ -17233,6 +18606,14 @@ module Prism
17233
18606
  def self.type
17234
18607
  :statements_node
17235
18608
  end
18609
+
18610
+ # Implements case-equality for the node. This is effectively == but without
18611
+ # comparing the value of locations. Locations are checked only for presence.
18612
+ def ===(other)
18613
+ other.is_a?(StatementsNode) &&
18614
+ (body.length == other.body.length) &&
18615
+ body.zip(other.body).all? { |left, right| left === right }
18616
+ end
17236
18617
  end
17237
18618
 
17238
18619
  # 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
17291
18672
  { flags: flags, opening_loc: opening_loc, content_loc: content_loc, closing_loc: closing_loc, unescaped: unescaped, location: location }
17292
18673
  end
17293
18674
 
17294
- # private attr_reader flags: Integer
18675
+ # protected attr_reader flags: Integer
17295
18676
  attr_reader :flags
17296
- private :flags
18677
+ protected :flags
17297
18678
 
17298
18679
  # attr_reader opening_loc: Location?
17299
18680
  def opening_loc
@@ -17331,7 +18712,6 @@ module Prism
17331
18712
  # attr_reader unescaped: String
17332
18713
  attr_reader :unescaped
17333
18714
 
17334
-
17335
18715
  # def forced_utf8_encoding?: () -> bool
17336
18716
  def forced_utf8_encoding?
17337
18717
  flags.anybits?(StringFlags::FORCED_UTF8_ENCODING)
@@ -17406,6 +18786,17 @@ module Prism
17406
18786
  def self.type
17407
18787
  :string_node
17408
18788
  end
18789
+
18790
+ # Implements case-equality for the node. This is effectively == but without
18791
+ # comparing the value of locations. Locations are checked only for presence.
18792
+ def ===(other)
18793
+ other.is_a?(StringNode) &&
18794
+ (flags === other.flags) &&
18795
+ (opening_loc.nil? == other.opening_loc.nil?) &&
18796
+ (content_loc.nil? == other.content_loc.nil?) &&
18797
+ (closing_loc.nil? == other.closing_loc.nil?) &&
18798
+ (unescaped === other.unescaped)
18799
+ end
17409
18800
  end
17410
18801
 
17411
18802
  # Represents the use of the `super` keyword with parentheses or arguments.
@@ -17503,7 +18894,6 @@ module Prism
17503
18894
  # attr_reader block: Prism::node?
17504
18895
  attr_reader :block
17505
18896
 
17506
-
17507
18897
  # def keyword: () -> String
17508
18898
  def keyword
17509
18899
  keyword_loc.slice
@@ -17567,6 +18957,17 @@ module Prism
17567
18957
  def self.type
17568
18958
  :super_node
17569
18959
  end
18960
+
18961
+ # Implements case-equality for the node. This is effectively == but without
18962
+ # comparing the value of locations. Locations are checked only for presence.
18963
+ def ===(other)
18964
+ other.is_a?(SuperNode) &&
18965
+ (keyword_loc.nil? == other.keyword_loc.nil?) &&
18966
+ (lparen_loc.nil? == other.lparen_loc.nil?) &&
18967
+ (arguments === other.arguments) &&
18968
+ (rparen_loc.nil? == other.rparen_loc.nil?) &&
18969
+ (block === other.block)
18970
+ end
17570
18971
  end
17571
18972
 
17572
18973
  # Represents a symbol literal or a symbol contained within a `%i` list.
@@ -17622,9 +19023,9 @@ module Prism
17622
19023
  { flags: flags, opening_loc: opening_loc, value_loc: value_loc, closing_loc: closing_loc, unescaped: unescaped, location: location }
17623
19024
  end
17624
19025
 
17625
- # private attr_reader flags: Integer
19026
+ # protected attr_reader flags: Integer
17626
19027
  attr_reader :flags
17627
- private :flags
19028
+ protected :flags
17628
19029
 
17629
19030
  # attr_reader opening_loc: Location?
17630
19031
  def opening_loc
@@ -17668,7 +19069,6 @@ module Prism
17668
19069
  # attr_reader unescaped: String
17669
19070
  attr_reader :unescaped
17670
19071
 
17671
-
17672
19072
  # def forced_utf8_encoding?: () -> bool
17673
19073
  def forced_utf8_encoding?
17674
19074
  flags.anybits?(SymbolFlags::FORCED_UTF8_ENCODING)
@@ -17738,6 +19138,17 @@ module Prism
17738
19138
  def self.type
17739
19139
  :symbol_node
17740
19140
  end
19141
+
19142
+ # Implements case-equality for the node. This is effectively == but without
19143
+ # comparing the value of locations. Locations are checked only for presence.
19144
+ def ===(other)
19145
+ other.is_a?(SymbolNode) &&
19146
+ (flags === other.flags) &&
19147
+ (opening_loc.nil? == other.opening_loc.nil?) &&
19148
+ (value_loc.nil? == other.value_loc.nil?) &&
19149
+ (closing_loc.nil? == other.closing_loc.nil?) &&
19150
+ (unescaped === other.unescaped)
19151
+ end
17741
19152
  end
17742
19153
 
17743
19154
  # Represents the use of the literal `true` keyword.
@@ -17785,7 +19196,6 @@ module Prism
17785
19196
  { location: location }
17786
19197
  end
17787
19198
 
17788
-
17789
19199
  # def inspect(NodeInspector inspector) -> String
17790
19200
  def inspect(inspector = NodeInspector.new)
17791
19201
  inspector << inspector.header(self)
@@ -17819,6 +19229,12 @@ module Prism
17819
19229
  def self.type
17820
19230
  :true_node
17821
19231
  end
19232
+
19233
+ # Implements case-equality for the node. This is effectively == but without
19234
+ # comparing the value of locations. Locations are checked only for presence.
19235
+ def ===(other)
19236
+ other.is_a?(TrueNode)
19237
+ end
17822
19238
  end
17823
19239
 
17824
19240
  # Represents the use of the `undef` keyword.
@@ -17878,7 +19294,6 @@ module Prism
17878
19294
  @keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
17879
19295
  end
17880
19296
 
17881
-
17882
19297
  # def keyword: () -> String
17883
19298
  def keyword
17884
19299
  keyword_loc.slice
@@ -17919,6 +19334,15 @@ module Prism
17919
19334
  def self.type
17920
19335
  :undef_node
17921
19336
  end
19337
+
19338
+ # Implements case-equality for the node. This is effectively == but without
19339
+ # comparing the value of locations. Locations are checked only for presence.
19340
+ def ===(other)
19341
+ other.is_a?(UndefNode) &&
19342
+ (names.length == other.names.length) &&
19343
+ names.zip(other.names).all? { |left, right| left === right } &&
19344
+ (keyword_loc.nil? == other.keyword_loc.nil?)
19345
+ end
17922
19346
  end
17923
19347
 
17924
19348
  # Represents the use of the `unless` keyword, either in the block form or the modifier form.
@@ -17983,17 +19407,30 @@ module Prism
17983
19407
  { keyword_loc: keyword_loc, predicate: predicate, then_keyword_loc: then_keyword_loc, statements: statements, consequent: consequent, end_keyword_loc: end_keyword_loc, location: location }
17984
19408
  end
17985
19409
 
17986
- # attr_reader keyword_loc: Location
19410
+ # The location of the `unless` keyword.
19411
+ #
19412
+ # unless cond then bar end
19413
+ # ^^^^^^
19414
+ #
19415
+ # bar unless cond
19416
+ # ^^^^^^
17987
19417
  def keyword_loc
17988
19418
  location = @keyword_loc
17989
19419
  return location if location.is_a?(Location)
17990
19420
  @keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
17991
19421
  end
17992
19422
 
17993
- # attr_reader predicate: Prism::node
19423
+ # 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).
19424
+ #
19425
+ # unless cond then bar end
19426
+ # ^^^^
19427
+ #
19428
+ # bar unless cond
19429
+ # ^^^^
17994
19430
  attr_reader :predicate
17995
19431
 
17996
- # attr_reader then_keyword_loc: Location?
19432
+ # The location of the `then` keyword, if present.
19433
+ # unless cond then bar end ^^^^
17997
19434
  def then_keyword_loc
17998
19435
  location = @then_keyword_loc
17999
19436
  case location
@@ -18006,13 +19443,23 @@ module Prism
18006
19443
  end
18007
19444
  end
18008
19445
 
18009
- # attr_reader statements: StatementsNode?
19446
+ # The body of statements that will executed if the unless condition is
19447
+ # falsey. Will be `nil` if no body is provided.
19448
+ #
19449
+ # unless cond then bar end
19450
+ # ^^^
18010
19451
  attr_reader :statements
18011
19452
 
18012
- # attr_reader consequent: ElseNode?
19453
+ # The else clause of the unless expression, if present.
19454
+ #
19455
+ # unless cond then bar else baz end
19456
+ # ^^^^^^^^
18013
19457
  attr_reader :consequent
18014
19458
 
18015
- # attr_reader end_keyword_loc: Location?
19459
+ # The location of the `end` keyword, if present.
19460
+ #
19461
+ # unless cond then bar end
19462
+ # ^^^
18016
19463
  def end_keyword_loc
18017
19464
  location = @end_keyword_loc
18018
19465
  case location
@@ -18025,7 +19472,6 @@ module Prism
18025
19472
  end
18026
19473
  end
18027
19474
 
18028
-
18029
19475
  # def keyword: () -> String
18030
19476
  def keyword
18031
19477
  keyword_loc.slice
@@ -18091,6 +19537,18 @@ module Prism
18091
19537
  def self.type
18092
19538
  :unless_node
18093
19539
  end
19540
+
19541
+ # Implements case-equality for the node. This is effectively == but without
19542
+ # comparing the value of locations. Locations are checked only for presence.
19543
+ def ===(other)
19544
+ other.is_a?(UnlessNode) &&
19545
+ (keyword_loc.nil? == other.keyword_loc.nil?) &&
19546
+ (predicate === other.predicate) &&
19547
+ (then_keyword_loc.nil? == other.then_keyword_loc.nil?) &&
19548
+ (statements === other.statements) &&
19549
+ (consequent === other.consequent) &&
19550
+ (end_keyword_loc.nil? == other.end_keyword_loc.nil?)
19551
+ end
18094
19552
  end
18095
19553
 
18096
19554
  # Represents the use of the `until` keyword, either in the block form or the modifier form.
@@ -18153,9 +19611,9 @@ module Prism
18153
19611
  { flags: flags, keyword_loc: keyword_loc, closing_loc: closing_loc, predicate: predicate, statements: statements, location: location }
18154
19612
  end
18155
19613
 
18156
- # private attr_reader flags: Integer
19614
+ # protected attr_reader flags: Integer
18157
19615
  attr_reader :flags
18158
- private :flags
19616
+ protected :flags
18159
19617
 
18160
19618
  # attr_reader keyword_loc: Location
18161
19619
  def keyword_loc
@@ -18183,7 +19641,6 @@ module Prism
18183
19641
  # attr_reader statements: StatementsNode?
18184
19642
  attr_reader :statements
18185
19643
 
18186
-
18187
19644
  # def begin_modifier?: () -> bool
18188
19645
  def begin_modifier?
18189
19646
  flags.anybits?(LoopFlags::BEGIN_MODIFIER)
@@ -18244,6 +19701,17 @@ module Prism
18244
19701
  def self.type
18245
19702
  :until_node
18246
19703
  end
19704
+
19705
+ # Implements case-equality for the node. This is effectively == but without
19706
+ # comparing the value of locations. Locations are checked only for presence.
19707
+ def ===(other)
19708
+ other.is_a?(UntilNode) &&
19709
+ (flags === other.flags) &&
19710
+ (keyword_loc.nil? == other.keyword_loc.nil?) &&
19711
+ (closing_loc.nil? == other.closing_loc.nil?) &&
19712
+ (predicate === other.predicate) &&
19713
+ (statements === other.statements)
19714
+ end
18247
19715
  end
18248
19716
 
18249
19717
  # Represents the use of the `when` keyword within a case statement.
@@ -18326,7 +19794,6 @@ module Prism
18326
19794
  # attr_reader statements: StatementsNode?
18327
19795
  attr_reader :statements
18328
19796
 
18329
-
18330
19797
  # def keyword: () -> String
18331
19798
  def keyword
18332
19799
  keyword_loc.slice
@@ -18379,6 +19846,17 @@ module Prism
18379
19846
  def self.type
18380
19847
  :when_node
18381
19848
  end
19849
+
19850
+ # Implements case-equality for the node. This is effectively == but without
19851
+ # comparing the value of locations. Locations are checked only for presence.
19852
+ def ===(other)
19853
+ other.is_a?(WhenNode) &&
19854
+ (keyword_loc.nil? == other.keyword_loc.nil?) &&
19855
+ (conditions.length == other.conditions.length) &&
19856
+ conditions.zip(other.conditions).all? { |left, right| left === right } &&
19857
+ (then_keyword_loc.nil? == other.then_keyword_loc.nil?) &&
19858
+ (statements === other.statements)
19859
+ end
18382
19860
  end
18383
19861
 
18384
19862
  # Represents the use of the `while` keyword, either in the block form or the modifier form.
@@ -18441,9 +19919,9 @@ module Prism
18441
19919
  { flags: flags, keyword_loc: keyword_loc, closing_loc: closing_loc, predicate: predicate, statements: statements, location: location }
18442
19920
  end
18443
19921
 
18444
- # private attr_reader flags: Integer
19922
+ # protected attr_reader flags: Integer
18445
19923
  attr_reader :flags
18446
- private :flags
19924
+ protected :flags
18447
19925
 
18448
19926
  # attr_reader keyword_loc: Location
18449
19927
  def keyword_loc
@@ -18471,7 +19949,6 @@ module Prism
18471
19949
  # attr_reader statements: StatementsNode?
18472
19950
  attr_reader :statements
18473
19951
 
18474
-
18475
19952
  # def begin_modifier?: () -> bool
18476
19953
  def begin_modifier?
18477
19954
  flags.anybits?(LoopFlags::BEGIN_MODIFIER)
@@ -18532,6 +20009,17 @@ module Prism
18532
20009
  def self.type
18533
20010
  :while_node
18534
20011
  end
20012
+
20013
+ # Implements case-equality for the node. This is effectively == but without
20014
+ # comparing the value of locations. Locations are checked only for presence.
20015
+ def ===(other)
20016
+ other.is_a?(WhileNode) &&
20017
+ (flags === other.flags) &&
20018
+ (keyword_loc.nil? == other.keyword_loc.nil?) &&
20019
+ (closing_loc.nil? == other.closing_loc.nil?) &&
20020
+ (predicate === other.predicate) &&
20021
+ (statements === other.statements)
20022
+ end
18535
20023
  end
18536
20024
 
18537
20025
  # Represents an xstring literal with no interpolation.
@@ -18584,9 +20072,9 @@ module Prism
18584
20072
  { flags: flags, opening_loc: opening_loc, content_loc: content_loc, closing_loc: closing_loc, unescaped: unescaped, location: location }
18585
20073
  end
18586
20074
 
18587
- # private attr_reader flags: Integer
20075
+ # protected attr_reader flags: Integer
18588
20076
  attr_reader :flags
18589
- private :flags
20077
+ protected :flags
18590
20078
 
18591
20079
  # attr_reader opening_loc: Location
18592
20080
  def opening_loc
@@ -18612,7 +20100,6 @@ module Prism
18612
20100
  # attr_reader unescaped: String
18613
20101
  attr_reader :unescaped
18614
20102
 
18615
-
18616
20103
  # def forced_utf8_encoding?: () -> bool
18617
20104
  def forced_utf8_encoding?
18618
20105
  flags.anybits?(EncodingFlags::FORCED_UTF8_ENCODING)
@@ -18677,6 +20164,17 @@ module Prism
18677
20164
  def self.type
18678
20165
  :x_string_node
18679
20166
  end
20167
+
20168
+ # Implements case-equality for the node. This is effectively == but without
20169
+ # comparing the value of locations. Locations are checked only for presence.
20170
+ def ===(other)
20171
+ other.is_a?(XStringNode) &&
20172
+ (flags === other.flags) &&
20173
+ (opening_loc.nil? == other.opening_loc.nil?) &&
20174
+ (content_loc.nil? == other.content_loc.nil?) &&
20175
+ (closing_loc.nil? == other.closing_loc.nil?) &&
20176
+ (unescaped === other.unescaped)
20177
+ end
18680
20178
  end
18681
20179
 
18682
20180
  # Represents the use of the `yield` keyword.
@@ -18766,7 +20264,6 @@ module Prism
18766
20264
  end
18767
20265
  end
18768
20266
 
18769
-
18770
20267
  # def keyword: () -> String
18771
20268
  def keyword
18772
20269
  keyword_loc.slice
@@ -18824,6 +20321,16 @@ module Prism
18824
20321
  def self.type
18825
20322
  :yield_node
18826
20323
  end
20324
+
20325
+ # Implements case-equality for the node. This is effectively == but without
20326
+ # comparing the value of locations. Locations are checked only for presence.
20327
+ def ===(other)
20328
+ other.is_a?(YieldNode) &&
20329
+ (keyword_loc.nil? == other.keyword_loc.nil?) &&
20330
+ (lparen_loc.nil? == other.lparen_loc.nil?) &&
20331
+ (arguments === other.arguments) &&
20332
+ (rparen_loc.nil? == other.rparen_loc.nil?)
20333
+ end
18827
20334
  end
18828
20335
 
18829
20336
  # Flags for arguments nodes.