prism 0.13.0 → 0.15.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
@@ -130,6 +130,16 @@ module Prism
130
130
  def type
131
131
  :alias_global_variable_node
132
132
  end
133
+
134
+ # Similar to #type, this method returns a symbol that you can use for
135
+ # splitting on the type of the node without having to do a long === chain.
136
+ # Note that like #type, it will still be slower than using == for a single
137
+ # class, but should be faster in a case statement or an array comparison.
138
+ #
139
+ # def self.type: () -> Symbol
140
+ def self.type
141
+ :alias_global_variable_node
142
+ end
133
143
  end
134
144
 
135
145
  # Represents the use of the `alias` keyword to alias a method.
@@ -224,6 +234,16 @@ module Prism
224
234
  def type
225
235
  :alias_method_node
226
236
  end
237
+
238
+ # Similar to #type, this method returns a symbol that you can use for
239
+ # splitting on the type of the node without having to do a long === chain.
240
+ # Note that like #type, it will still be slower than using == for a single
241
+ # class, but should be faster in a case statement or an array comparison.
242
+ #
243
+ # def self.type: () -> Symbol
244
+ def self.type
245
+ :alias_method_node
246
+ end
227
247
  end
228
248
 
229
249
  # Represents an alternation pattern in pattern matching.
@@ -318,6 +338,16 @@ module Prism
318
338
  def type
319
339
  :alternation_pattern_node
320
340
  end
341
+
342
+ # Similar to #type, this method returns a symbol that you can use for
343
+ # splitting on the type of the node without having to do a long === chain.
344
+ # Note that like #type, it will still be slower than using == for a single
345
+ # class, but should be faster in a case statement or an array comparison.
346
+ #
347
+ # def self.type: () -> Symbol
348
+ def self.type
349
+ :alternation_pattern_node
350
+ end
321
351
  end
322
352
 
323
353
  # Represents the use of the `&&` operator or the `and` keyword.
@@ -412,6 +442,16 @@ module Prism
412
442
  def type
413
443
  :and_node
414
444
  end
445
+
446
+ # Similar to #type, this method returns a symbol that you can use for
447
+ # splitting on the type of the node without having to do a long === chain.
448
+ # Note that like #type, it will still be slower than using == for a single
449
+ # class, but should be faster in a case statement or an array comparison.
450
+ #
451
+ # def self.type: () -> Symbol
452
+ def self.type
453
+ :and_node
454
+ end
415
455
  end
416
456
 
417
457
  # Represents a set of arguments to a method or a keyword.
@@ -487,6 +527,16 @@ module Prism
487
527
  def type
488
528
  :arguments_node
489
529
  end
530
+
531
+ # Similar to #type, this method returns a symbol that you can use for
532
+ # splitting on the type of the node without having to do a long === chain.
533
+ # Note that like #type, it will still be slower than using == for a single
534
+ # class, but should be faster in a case statement or an array comparison.
535
+ #
536
+ # def self.type: () -> Symbol
537
+ def self.type
538
+ :arguments_node
539
+ end
490
540
  end
491
541
 
492
542
  # Represents an array literal. This can be a regular array using brackets or
@@ -585,6 +635,16 @@ module Prism
585
635
  def type
586
636
  :array_node
587
637
  end
638
+
639
+ # Similar to #type, this method returns a symbol that you can use for
640
+ # splitting on the type of the node without having to do a long === chain.
641
+ # Note that like #type, it will still be slower than using == for a single
642
+ # class, but should be faster in a case statement or an array comparison.
643
+ #
644
+ # def self.type: () -> Symbol
645
+ def self.type
646
+ :array_node
647
+ end
588
648
  end
589
649
 
590
650
  # Represents an array pattern in pattern matching.
@@ -727,6 +787,16 @@ module Prism
727
787
  def type
728
788
  :array_pattern_node
729
789
  end
790
+
791
+ # Similar to #type, this method returns a symbol that you can use for
792
+ # splitting on the type of the node without having to do a long === chain.
793
+ # Note that like #type, it will still be slower than using == for a single
794
+ # class, but should be faster in a case statement or an array comparison.
795
+ #
796
+ # def self.type: () -> Symbol
797
+ def self.type
798
+ :array_pattern_node
799
+ end
730
800
  end
731
801
 
732
802
  # Represents a hash key/value pair.
@@ -828,6 +898,16 @@ module Prism
828
898
  def type
829
899
  :assoc_node
830
900
  end
901
+
902
+ # Similar to #type, this method returns a symbol that you can use for
903
+ # splitting on the type of the node without having to do a long === chain.
904
+ # Note that like #type, it will still be slower than using == for a single
905
+ # class, but should be faster in a case statement or an array comparison.
906
+ #
907
+ # def self.type: () -> Symbol
908
+ def self.type
909
+ :assoc_node
910
+ end
831
911
  end
832
912
 
833
913
  # Represents a splat in a hash literal.
@@ -921,6 +1001,16 @@ module Prism
921
1001
  def type
922
1002
  :assoc_splat_node
923
1003
  end
1004
+
1005
+ # Similar to #type, this method returns a symbol that you can use for
1006
+ # splitting on the type of the node without having to do a long === chain.
1007
+ # Note that like #type, it will still be slower than using == for a single
1008
+ # class, but should be faster in a case statement or an array comparison.
1009
+ #
1010
+ # def self.type: () -> Symbol
1011
+ def self.type
1012
+ :assoc_splat_node
1013
+ end
924
1014
  end
925
1015
 
926
1016
  # Represents reading a reference to a field in the previous match.
@@ -928,8 +1018,12 @@ module Prism
928
1018
  # $'
929
1019
  # ^^
930
1020
  class BackReferenceReadNode < Node
931
- # def initialize: (location: Location) -> void
932
- def initialize(location)
1021
+ # attr_reader name: Symbol
1022
+ attr_reader :name
1023
+
1024
+ # def initialize: (name: Symbol, location: Location) -> void
1025
+ def initialize(name, location)
1026
+ @name = name
933
1027
  @location = location
934
1028
  end
935
1029
 
@@ -956,6 +1050,7 @@ module Prism
956
1050
  # def copy: (**params) -> BackReferenceReadNode
957
1051
  def copy(**params)
958
1052
  BackReferenceReadNode.new(
1053
+ params.fetch(:name) { name },
959
1054
  params.fetch(:location) { location },
960
1055
  )
961
1056
  end
@@ -965,11 +1060,12 @@ module Prism
965
1060
 
966
1061
  # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
967
1062
  def deconstruct_keys(keys)
968
- { location: location }
1063
+ { name: name, location: location }
969
1064
  end
970
1065
 
971
1066
  def inspect(inspector = NodeInspector.new)
972
1067
  inspector << inspector.header(self)
1068
+ inspector << "└── name: #{name.inspect}\n"
973
1069
  inspector.to_str
974
1070
  end
975
1071
 
@@ -990,6 +1086,16 @@ module Prism
990
1086
  def type
991
1087
  :back_reference_read_node
992
1088
  end
1089
+
1090
+ # Similar to #type, this method returns a symbol that you can use for
1091
+ # splitting on the type of the node without having to do a long === chain.
1092
+ # Note that like #type, it will still be slower than using == for a single
1093
+ # class, but should be faster in a case statement or an array comparison.
1094
+ #
1095
+ # def self.type: () -> Symbol
1096
+ def self.type
1097
+ :back_reference_read_node
1098
+ end
993
1099
  end
994
1100
 
995
1101
  # Represents a begin statement.
@@ -1136,6 +1242,16 @@ module Prism
1136
1242
  def type
1137
1243
  :begin_node
1138
1244
  end
1245
+
1246
+ # Similar to #type, this method returns a symbol that you can use for
1247
+ # splitting on the type of the node without having to do a long === chain.
1248
+ # Note that like #type, it will still be slower than using == for a single
1249
+ # class, but should be faster in a case statement or an array comparison.
1250
+ #
1251
+ # def self.type: () -> Symbol
1252
+ def self.type
1253
+ :begin_node
1254
+ end
1139
1255
  end
1140
1256
 
1141
1257
  # Represents block method arguments.
@@ -1229,6 +1345,16 @@ module Prism
1229
1345
  def type
1230
1346
  :block_argument_node
1231
1347
  end
1348
+
1349
+ # Similar to #type, this method returns a symbol that you can use for
1350
+ # splitting on the type of the node without having to do a long === chain.
1351
+ # Note that like #type, it will still be slower than using == for a single
1352
+ # class, but should be faster in a case statement or an array comparison.
1353
+ #
1354
+ # def self.type: () -> Symbol
1355
+ def self.type
1356
+ :block_argument_node
1357
+ end
1232
1358
  end
1233
1359
 
1234
1360
  # Represents a block local variable.
@@ -1304,6 +1430,16 @@ module Prism
1304
1430
  def type
1305
1431
  :block_local_variable_node
1306
1432
  end
1433
+
1434
+ # Similar to #type, this method returns a symbol that you can use for
1435
+ # splitting on the type of the node without having to do a long === chain.
1436
+ # Note that like #type, it will still be slower than using == for a single
1437
+ # class, but should be faster in a case statement or an array comparison.
1438
+ #
1439
+ # def self.type: () -> Symbol
1440
+ def self.type
1441
+ :block_local_variable_node
1442
+ end
1307
1443
  end
1308
1444
 
1309
1445
  # Represents a block of ruby code.
@@ -1426,6 +1562,16 @@ module Prism
1426
1562
  def type
1427
1563
  :block_node
1428
1564
  end
1565
+
1566
+ # Similar to #type, this method returns a symbol that you can use for
1567
+ # splitting on the type of the node without having to do a long === chain.
1568
+ # Note that like #type, it will still be slower than using == for a single
1569
+ # class, but should be faster in a case statement or an array comparison.
1570
+ #
1571
+ # def self.type: () -> Symbol
1572
+ def self.type
1573
+ :block_node
1574
+ end
1429
1575
  end
1430
1576
 
1431
1577
  # Represents a block parameter to a method, block, or lambda definition.
@@ -1519,6 +1665,16 @@ module Prism
1519
1665
  def type
1520
1666
  :block_parameter_node
1521
1667
  end
1668
+
1669
+ # Similar to #type, this method returns a symbol that you can use for
1670
+ # splitting on the type of the node without having to do a long === chain.
1671
+ # Note that like #type, it will still be slower than using == for a single
1672
+ # class, but should be faster in a case statement or an array comparison.
1673
+ #
1674
+ # def self.type: () -> Symbol
1675
+ def self.type
1676
+ :block_parameter_node
1677
+ end
1522
1678
  end
1523
1679
 
1524
1680
  # Represents a block's parameters declaration.
@@ -1634,6 +1790,16 @@ module Prism
1634
1790
  def type
1635
1791
  :block_parameters_node
1636
1792
  end
1793
+
1794
+ # Similar to #type, this method returns a symbol that you can use for
1795
+ # splitting on the type of the node without having to do a long === chain.
1796
+ # Note that like #type, it will still be slower than using == for a single
1797
+ # class, but should be faster in a case statement or an array comparison.
1798
+ #
1799
+ # def self.type: () -> Symbol
1800
+ def self.type
1801
+ :block_parameters_node
1802
+ end
1637
1803
  end
1638
1804
 
1639
1805
  # Represents the use of the `break` keyword.
@@ -1727,6 +1893,16 @@ module Prism
1727
1893
  def type
1728
1894
  :break_node
1729
1895
  end
1896
+
1897
+ # Similar to #type, this method returns a symbol that you can use for
1898
+ # splitting on the type of the node without having to do a long === chain.
1899
+ # Note that like #type, it will still be slower than using == for a single
1900
+ # class, but should be faster in a case statement or an array comparison.
1901
+ #
1902
+ # def self.type: () -> Symbol
1903
+ def self.type
1904
+ :break_node
1905
+ end
1730
1906
  end
1731
1907
 
1732
1908
  # Represents the use of the `&&=` operator on a call.
@@ -1743,22 +1919,13 @@ module Prism
1743
1919
  # attr_reader message_loc: Location?
1744
1920
  attr_reader :message_loc
1745
1921
 
1746
- # attr_reader opening_loc: Location?
1747
- attr_reader :opening_loc
1748
-
1749
- # attr_reader arguments: ArgumentsNode?
1750
- attr_reader :arguments
1751
-
1752
- # attr_reader closing_loc: Location?
1753
- attr_reader :closing_loc
1754
-
1755
1922
  # attr_reader flags: Integer
1756
1923
  private attr_reader :flags
1757
1924
 
1758
- # attr_reader read_name: String
1925
+ # attr_reader read_name: Symbol
1759
1926
  attr_reader :read_name
1760
1927
 
1761
- # attr_reader write_name: String
1928
+ # attr_reader write_name: Symbol
1762
1929
  attr_reader :write_name
1763
1930
 
1764
1931
  # attr_reader operator_loc: Location
@@ -1767,14 +1934,11 @@ module Prism
1767
1934
  # attr_reader value: Node
1768
1935
  attr_reader :value
1769
1936
 
1770
- # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, flags: Integer, read_name: String, write_name: String, operator_loc: Location, value: Node, location: Location) -> void
1771
- def initialize(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location)
1937
+ # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, flags: Integer, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location) -> void
1938
+ def initialize(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator_loc, value, location)
1772
1939
  @receiver = receiver
1773
1940
  @call_operator_loc = call_operator_loc
1774
1941
  @message_loc = message_loc
1775
- @opening_loc = opening_loc
1776
- @arguments = arguments
1777
- @closing_loc = closing_loc
1778
1942
  @flags = flags
1779
1943
  @read_name = read_name
1780
1944
  @write_name = write_name
@@ -1790,21 +1954,20 @@ module Prism
1790
1954
 
1791
1955
  # def child_nodes: () -> Array[nil | Node]
1792
1956
  def child_nodes
1793
- [receiver, arguments, value]
1957
+ [receiver, value]
1794
1958
  end
1795
1959
 
1796
1960
  # def compact_child_nodes: () -> Array[Node]
1797
1961
  def compact_child_nodes
1798
1962
  compact = []
1799
1963
  compact << receiver if receiver
1800
- compact << arguments if arguments
1801
1964
  compact << value
1802
1965
  compact
1803
1966
  end
1804
1967
 
1805
1968
  # def comment_targets: () -> Array[Node | Location]
1806
1969
  def comment_targets
1807
- [*receiver, *call_operator_loc, *message_loc, *opening_loc, *arguments, *closing_loc, operator_loc, value]
1970
+ [*receiver, *call_operator_loc, *message_loc, operator_loc, value]
1808
1971
  end
1809
1972
 
1810
1973
  # def copy: (**params) -> CallAndWriteNode
@@ -1813,9 +1976,6 @@ module Prism
1813
1976
  params.fetch(:receiver) { receiver },
1814
1977
  params.fetch(:call_operator_loc) { call_operator_loc },
1815
1978
  params.fetch(:message_loc) { message_loc },
1816
- params.fetch(:opening_loc) { opening_loc },
1817
- params.fetch(:arguments) { arguments },
1818
- params.fetch(:closing_loc) { closing_loc },
1819
1979
  params.fetch(:flags) { flags },
1820
1980
  params.fetch(:read_name) { read_name },
1821
1981
  params.fetch(:write_name) { write_name },
@@ -1830,7 +1990,7 @@ module Prism
1830
1990
 
1831
1991
  # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
1832
1992
  def deconstruct_keys(keys)
1833
- { receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, flags: flags, read_name: read_name, write_name: write_name, operator_loc: operator_loc, value: value, location: location }
1993
+ { receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, flags: flags, read_name: read_name, write_name: write_name, operator_loc: operator_loc, value: value, location: location }
1834
1994
  end
1835
1995
 
1836
1996
  # def call_operator: () -> String?
@@ -1843,16 +2003,6 @@ module Prism
1843
2003
  message_loc&.slice
1844
2004
  end
1845
2005
 
1846
- # def opening: () -> String?
1847
- def opening
1848
- opening_loc&.slice
1849
- end
1850
-
1851
- # def closing: () -> String?
1852
- def closing
1853
- closing_loc&.slice
1854
- end
1855
-
1856
2006
  # def safe_navigation?: () -> bool
1857
2007
  def safe_navigation?
1858
2008
  flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -1878,14 +2028,6 @@ module Prism
1878
2028
  end
1879
2029
  inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
1880
2030
  inspector << "├── message_loc: #{inspector.location(message_loc)}\n"
1881
- inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
1882
- if (arguments = self.arguments).nil?
1883
- inspector << "├── arguments: ∅\n"
1884
- else
1885
- inspector << "├── arguments:\n"
1886
- inspector << arguments.inspect(inspector.child_inspector("│ ")).delete_prefix(inspector.prefix)
1887
- end
1888
- inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
1889
2031
  flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
1890
2032
  inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
1891
2033
  inspector << "├── read_name: #{read_name.inspect}\n"
@@ -1913,6 +2055,16 @@ module Prism
1913
2055
  def type
1914
2056
  :call_and_write_node
1915
2057
  end
2058
+
2059
+ # Similar to #type, this method returns a symbol that you can use for
2060
+ # splitting on the type of the node without having to do a long === chain.
2061
+ # Note that like #type, it will still be slower than using == for a single
2062
+ # class, but should be faster in a case statement or an array comparison.
2063
+ #
2064
+ # def self.type: () -> Symbol
2065
+ def self.type
2066
+ :call_and_write_node
2067
+ end
1916
2068
  end
1917
2069
 
1918
2070
  # Represents a method call, in all of the various forms that can take.
@@ -1959,10 +2111,10 @@ module Prism
1959
2111
  # attr_reader flags: Integer
1960
2112
  private attr_reader :flags
1961
2113
 
1962
- # attr_reader name: String
2114
+ # attr_reader name: Symbol
1963
2115
  attr_reader :name
1964
2116
 
1965
- # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: Node?, flags: Integer, name: String, location: Location) -> void
2117
+ # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: Node?, flags: Integer, name: Symbol, location: Location) -> void
1966
2118
  def initialize(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, block, flags, name, location)
1967
2119
  @receiver = receiver
1968
2120
  @call_operator_loc = call_operator_loc
@@ -2101,6 +2253,16 @@ module Prism
2101
2253
  def type
2102
2254
  :call_node
2103
2255
  end
2256
+
2257
+ # Similar to #type, this method returns a symbol that you can use for
2258
+ # splitting on the type of the node without having to do a long === chain.
2259
+ # Note that like #type, it will still be slower than using == for a single
2260
+ # class, but should be faster in a case statement or an array comparison.
2261
+ #
2262
+ # def self.type: () -> Symbol
2263
+ def self.type
2264
+ :call_node
2265
+ end
2104
2266
  end
2105
2267
 
2106
2268
  # Represents the use of an assignment operator on a call.
@@ -2117,22 +2279,13 @@ module Prism
2117
2279
  # attr_reader message_loc: Location?
2118
2280
  attr_reader :message_loc
2119
2281
 
2120
- # attr_reader opening_loc: Location?
2121
- attr_reader :opening_loc
2122
-
2123
- # attr_reader arguments: ArgumentsNode?
2124
- attr_reader :arguments
2125
-
2126
- # attr_reader closing_loc: Location?
2127
- attr_reader :closing_loc
2128
-
2129
2282
  # attr_reader flags: Integer
2130
2283
  private attr_reader :flags
2131
2284
 
2132
- # attr_reader read_name: String
2285
+ # attr_reader read_name: Symbol
2133
2286
  attr_reader :read_name
2134
2287
 
2135
- # attr_reader write_name: String
2288
+ # attr_reader write_name: Symbol
2136
2289
  attr_reader :write_name
2137
2290
 
2138
2291
  # attr_reader operator: Symbol
@@ -2144,14 +2297,11 @@ module Prism
2144
2297
  # attr_reader value: Node
2145
2298
  attr_reader :value
2146
2299
 
2147
- # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, flags: Integer, read_name: String, write_name: String, operator: Symbol, operator_loc: Location, value: Node, location: Location) -> void
2148
- def initialize(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator, operator_loc, value, location)
2300
+ # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, flags: Integer, read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Location, value: Node, location: Location) -> void
2301
+ def initialize(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator, operator_loc, value, location)
2149
2302
  @receiver = receiver
2150
2303
  @call_operator_loc = call_operator_loc
2151
2304
  @message_loc = message_loc
2152
- @opening_loc = opening_loc
2153
- @arguments = arguments
2154
- @closing_loc = closing_loc
2155
2305
  @flags = flags
2156
2306
  @read_name = read_name
2157
2307
  @write_name = write_name
@@ -2168,21 +2318,20 @@ module Prism
2168
2318
 
2169
2319
  # def child_nodes: () -> Array[nil | Node]
2170
2320
  def child_nodes
2171
- [receiver, arguments, value]
2321
+ [receiver, value]
2172
2322
  end
2173
2323
 
2174
2324
  # def compact_child_nodes: () -> Array[Node]
2175
2325
  def compact_child_nodes
2176
2326
  compact = []
2177
2327
  compact << receiver if receiver
2178
- compact << arguments if arguments
2179
2328
  compact << value
2180
2329
  compact
2181
2330
  end
2182
2331
 
2183
2332
  # def comment_targets: () -> Array[Node | Location]
2184
2333
  def comment_targets
2185
- [*receiver, *call_operator_loc, *message_loc, *opening_loc, *arguments, *closing_loc, operator_loc, value]
2334
+ [*receiver, *call_operator_loc, *message_loc, operator_loc, value]
2186
2335
  end
2187
2336
 
2188
2337
  # def copy: (**params) -> CallOperatorWriteNode
@@ -2191,9 +2340,6 @@ module Prism
2191
2340
  params.fetch(:receiver) { receiver },
2192
2341
  params.fetch(:call_operator_loc) { call_operator_loc },
2193
2342
  params.fetch(:message_loc) { message_loc },
2194
- params.fetch(:opening_loc) { opening_loc },
2195
- params.fetch(:arguments) { arguments },
2196
- params.fetch(:closing_loc) { closing_loc },
2197
2343
  params.fetch(:flags) { flags },
2198
2344
  params.fetch(:read_name) { read_name },
2199
2345
  params.fetch(:write_name) { write_name },
@@ -2209,7 +2355,7 @@ module Prism
2209
2355
 
2210
2356
  # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
2211
2357
  def deconstruct_keys(keys)
2212
- { receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, flags: flags, read_name: read_name, write_name: write_name, operator: operator, operator_loc: operator_loc, value: value, location: location }
2358
+ { receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, flags: flags, read_name: read_name, write_name: write_name, operator: operator, operator_loc: operator_loc, value: value, location: location }
2213
2359
  end
2214
2360
 
2215
2361
  # def call_operator: () -> String?
@@ -2222,16 +2368,6 @@ module Prism
2222
2368
  message_loc&.slice
2223
2369
  end
2224
2370
 
2225
- # def opening: () -> String?
2226
- def opening
2227
- opening_loc&.slice
2228
- end
2229
-
2230
- # def closing: () -> String?
2231
- def closing
2232
- closing_loc&.slice
2233
- end
2234
-
2235
2371
  # def safe_navigation?: () -> bool
2236
2372
  def safe_navigation?
2237
2373
  flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -2252,14 +2388,6 @@ module Prism
2252
2388
  end
2253
2389
  inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
2254
2390
  inspector << "├── message_loc: #{inspector.location(message_loc)}\n"
2255
- inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
2256
- if (arguments = self.arguments).nil?
2257
- inspector << "├── arguments: ∅\n"
2258
- else
2259
- inspector << "├── arguments:\n"
2260
- inspector << arguments.inspect(inspector.child_inspector("│ ")).delete_prefix(inspector.prefix)
2261
- end
2262
- inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
2263
2391
  flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
2264
2392
  inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
2265
2393
  inspector << "├── read_name: #{read_name.inspect}\n"
@@ -2288,6 +2416,16 @@ module Prism
2288
2416
  def type
2289
2417
  :call_operator_write_node
2290
2418
  end
2419
+
2420
+ # Similar to #type, this method returns a symbol that you can use for
2421
+ # splitting on the type of the node without having to do a long === chain.
2422
+ # Note that like #type, it will still be slower than using == for a single
2423
+ # class, but should be faster in a case statement or an array comparison.
2424
+ #
2425
+ # def self.type: () -> Symbol
2426
+ def self.type
2427
+ :call_operator_write_node
2428
+ end
2291
2429
  end
2292
2430
 
2293
2431
  # Represents the use of the `||=` operator on a call.
@@ -2304,22 +2442,13 @@ module Prism
2304
2442
  # attr_reader message_loc: Location?
2305
2443
  attr_reader :message_loc
2306
2444
 
2307
- # attr_reader opening_loc: Location?
2308
- attr_reader :opening_loc
2309
-
2310
- # attr_reader arguments: ArgumentsNode?
2311
- attr_reader :arguments
2312
-
2313
- # attr_reader closing_loc: Location?
2314
- attr_reader :closing_loc
2315
-
2316
2445
  # attr_reader flags: Integer
2317
2446
  private attr_reader :flags
2318
2447
 
2319
- # attr_reader read_name: String
2448
+ # attr_reader read_name: Symbol
2320
2449
  attr_reader :read_name
2321
2450
 
2322
- # attr_reader write_name: String
2451
+ # attr_reader write_name: Symbol
2323
2452
  attr_reader :write_name
2324
2453
 
2325
2454
  # attr_reader operator_loc: Location
@@ -2328,14 +2457,11 @@ module Prism
2328
2457
  # attr_reader value: Node
2329
2458
  attr_reader :value
2330
2459
 
2331
- # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, flags: Integer, read_name: String, write_name: String, operator_loc: Location, value: Node, location: Location) -> void
2332
- def initialize(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location)
2460
+ # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, flags: Integer, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location) -> void
2461
+ def initialize(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator_loc, value, location)
2333
2462
  @receiver = receiver
2334
2463
  @call_operator_loc = call_operator_loc
2335
2464
  @message_loc = message_loc
2336
- @opening_loc = opening_loc
2337
- @arguments = arguments
2338
- @closing_loc = closing_loc
2339
2465
  @flags = flags
2340
2466
  @read_name = read_name
2341
2467
  @write_name = write_name
@@ -2351,21 +2477,20 @@ module Prism
2351
2477
 
2352
2478
  # def child_nodes: () -> Array[nil | Node]
2353
2479
  def child_nodes
2354
- [receiver, arguments, value]
2480
+ [receiver, value]
2355
2481
  end
2356
2482
 
2357
2483
  # def compact_child_nodes: () -> Array[Node]
2358
2484
  def compact_child_nodes
2359
2485
  compact = []
2360
2486
  compact << receiver if receiver
2361
- compact << arguments if arguments
2362
2487
  compact << value
2363
2488
  compact
2364
2489
  end
2365
2490
 
2366
2491
  # def comment_targets: () -> Array[Node | Location]
2367
2492
  def comment_targets
2368
- [*receiver, *call_operator_loc, *message_loc, *opening_loc, *arguments, *closing_loc, operator_loc, value]
2493
+ [*receiver, *call_operator_loc, *message_loc, operator_loc, value]
2369
2494
  end
2370
2495
 
2371
2496
  # def copy: (**params) -> CallOrWriteNode
@@ -2374,9 +2499,6 @@ module Prism
2374
2499
  params.fetch(:receiver) { receiver },
2375
2500
  params.fetch(:call_operator_loc) { call_operator_loc },
2376
2501
  params.fetch(:message_loc) { message_loc },
2377
- params.fetch(:opening_loc) { opening_loc },
2378
- params.fetch(:arguments) { arguments },
2379
- params.fetch(:closing_loc) { closing_loc },
2380
2502
  params.fetch(:flags) { flags },
2381
2503
  params.fetch(:read_name) { read_name },
2382
2504
  params.fetch(:write_name) { write_name },
@@ -2391,7 +2513,7 @@ module Prism
2391
2513
 
2392
2514
  # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
2393
2515
  def deconstruct_keys(keys)
2394
- { receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, flags: flags, read_name: read_name, write_name: write_name, operator_loc: operator_loc, value: value, location: location }
2516
+ { receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, flags: flags, read_name: read_name, write_name: write_name, operator_loc: operator_loc, value: value, location: location }
2395
2517
  end
2396
2518
 
2397
2519
  # def call_operator: () -> String?
@@ -2404,16 +2526,6 @@ module Prism
2404
2526
  message_loc&.slice
2405
2527
  end
2406
2528
 
2407
- # def opening: () -> String?
2408
- def opening
2409
- opening_loc&.slice
2410
- end
2411
-
2412
- # def closing: () -> String?
2413
- def closing
2414
- closing_loc&.slice
2415
- end
2416
-
2417
2529
  # def safe_navigation?: () -> bool
2418
2530
  def safe_navigation?
2419
2531
  flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -2439,14 +2551,6 @@ module Prism
2439
2551
  end
2440
2552
  inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
2441
2553
  inspector << "├── message_loc: #{inspector.location(message_loc)}\n"
2442
- inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
2443
- if (arguments = self.arguments).nil?
2444
- inspector << "├── arguments: ∅\n"
2445
- else
2446
- inspector << "├── arguments:\n"
2447
- inspector << arguments.inspect(inspector.child_inspector("│ ")).delete_prefix(inspector.prefix)
2448
- end
2449
- inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
2450
2554
  flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
2451
2555
  inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
2452
2556
  inspector << "├── read_name: #{read_name.inspect}\n"
@@ -2474,6 +2578,16 @@ module Prism
2474
2578
  def type
2475
2579
  :call_or_write_node
2476
2580
  end
2581
+
2582
+ # Similar to #type, this method returns a symbol that you can use for
2583
+ # splitting on the type of the node without having to do a long === chain.
2584
+ # Note that like #type, it will still be slower than using == for a single
2585
+ # class, but should be faster in a case statement or an array comparison.
2586
+ #
2587
+ # def self.type: () -> Symbol
2588
+ def self.type
2589
+ :call_or_write_node
2590
+ end
2477
2591
  end
2478
2592
 
2479
2593
  # Represents assigning to a local variable in pattern matching.
@@ -2568,6 +2682,16 @@ module Prism
2568
2682
  def type
2569
2683
  :capture_pattern_node
2570
2684
  end
2685
+
2686
+ # Similar to #type, this method returns a symbol that you can use for
2687
+ # splitting on the type of the node without having to do a long === chain.
2688
+ # Note that like #type, it will still be slower than using == for a single
2689
+ # class, but should be faster in a case statement or an array comparison.
2690
+ #
2691
+ # def self.type: () -> Symbol
2692
+ def self.type
2693
+ :capture_pattern_node
2694
+ end
2571
2695
  end
2572
2696
 
2573
2697
  # Represents the use of a case statement.
@@ -2693,6 +2817,16 @@ module Prism
2693
2817
  def type
2694
2818
  :case_node
2695
2819
  end
2820
+
2821
+ # Similar to #type, this method returns a symbol that you can use for
2822
+ # splitting on the type of the node without having to do a long === chain.
2823
+ # Note that like #type, it will still be slower than using == for a single
2824
+ # class, but should be faster in a case statement or an array comparison.
2825
+ #
2826
+ # def self.type: () -> Symbol
2827
+ def self.type
2828
+ :case_node
2829
+ end
2696
2830
  end
2697
2831
 
2698
2832
  # Represents a class declaration involving the `class` keyword.
@@ -2840,6 +2974,16 @@ module Prism
2840
2974
  def type
2841
2975
  :class_node
2842
2976
  end
2977
+
2978
+ # Similar to #type, this method returns a symbol that you can use for
2979
+ # splitting on the type of the node without having to do a long === chain.
2980
+ # Note that like #type, it will still be slower than using == for a single
2981
+ # class, but should be faster in a case statement or an array comparison.
2982
+ #
2983
+ # def self.type: () -> Symbol
2984
+ def self.type
2985
+ :class_node
2986
+ end
2843
2987
  end
2844
2988
 
2845
2989
  # Represents the use of the `&&=` operator for assignment to a class variable.
@@ -2939,6 +3083,16 @@ module Prism
2939
3083
  def type
2940
3084
  :class_variable_and_write_node
2941
3085
  end
3086
+
3087
+ # Similar to #type, this method returns a symbol that you can use for
3088
+ # splitting on the type of the node without having to do a long === chain.
3089
+ # Note that like #type, it will still be slower than using == for a single
3090
+ # class, but should be faster in a case statement or an array comparison.
3091
+ #
3092
+ # def self.type: () -> Symbol
3093
+ def self.type
3094
+ :class_variable_and_write_node
3095
+ end
2942
3096
  end
2943
3097
 
2944
3098
  # Represents assigning to a class variable using an operator that isn't `=`.
@@ -3039,6 +3193,16 @@ module Prism
3039
3193
  def type
3040
3194
  :class_variable_operator_write_node
3041
3195
  end
3196
+
3197
+ # Similar to #type, this method returns a symbol that you can use for
3198
+ # splitting on the type of the node without having to do a long === chain.
3199
+ # Note that like #type, it will still be slower than using == for a single
3200
+ # class, but should be faster in a case statement or an array comparison.
3201
+ #
3202
+ # def self.type: () -> Symbol
3203
+ def self.type
3204
+ :class_variable_operator_write_node
3205
+ end
3042
3206
  end
3043
3207
 
3044
3208
  # Represents the use of the `||=` operator for assignment to a class variable.
@@ -3138,6 +3302,16 @@ module Prism
3138
3302
  def type
3139
3303
  :class_variable_or_write_node
3140
3304
  end
3305
+
3306
+ # Similar to #type, this method returns a symbol that you can use for
3307
+ # splitting on the type of the node without having to do a long === chain.
3308
+ # Note that like #type, it will still be slower than using == for a single
3309
+ # class, but should be faster in a case statement or an array comparison.
3310
+ #
3311
+ # def self.type: () -> Symbol
3312
+ def self.type
3313
+ :class_variable_or_write_node
3314
+ end
3141
3315
  end
3142
3316
 
3143
3317
  # Represents referencing a class variable.
@@ -3213,6 +3387,16 @@ module Prism
3213
3387
  def type
3214
3388
  :class_variable_read_node
3215
3389
  end
3390
+
3391
+ # Similar to #type, this method returns a symbol that you can use for
3392
+ # splitting on the type of the node without having to do a long === chain.
3393
+ # Note that like #type, it will still be slower than using == for a single
3394
+ # class, but should be faster in a case statement or an array comparison.
3395
+ #
3396
+ # def self.type: () -> Symbol
3397
+ def self.type
3398
+ :class_variable_read_node
3399
+ end
3216
3400
  end
3217
3401
 
3218
3402
  # Represents writing to a class variable in a context that doesn't have an explicit value.
@@ -3288,6 +3472,16 @@ module Prism
3288
3472
  def type
3289
3473
  :class_variable_target_node
3290
3474
  end
3475
+
3476
+ # Similar to #type, this method returns a symbol that you can use for
3477
+ # splitting on the type of the node without having to do a long === chain.
3478
+ # Note that like #type, it will still be slower than using == for a single
3479
+ # class, but should be faster in a case statement or an array comparison.
3480
+ #
3481
+ # def self.type: () -> Symbol
3482
+ def self.type
3483
+ :class_variable_target_node
3484
+ end
3291
3485
  end
3292
3486
 
3293
3487
  # Represents writing to a class variable.
@@ -3387,6 +3581,16 @@ module Prism
3387
3581
  def type
3388
3582
  :class_variable_write_node
3389
3583
  end
3584
+
3585
+ # Similar to #type, this method returns a symbol that you can use for
3586
+ # splitting on the type of the node without having to do a long === chain.
3587
+ # Note that like #type, it will still be slower than using == for a single
3588
+ # class, but should be faster in a case statement or an array comparison.
3589
+ #
3590
+ # def self.type: () -> Symbol
3591
+ def self.type
3592
+ :class_variable_write_node
3593
+ end
3390
3594
  end
3391
3595
 
3392
3596
  # Represents the use of the `&&=` operator for assignment to a constant.
@@ -3486,6 +3690,16 @@ module Prism
3486
3690
  def type
3487
3691
  :constant_and_write_node
3488
3692
  end
3693
+
3694
+ # Similar to #type, this method returns a symbol that you can use for
3695
+ # splitting on the type of the node without having to do a long === chain.
3696
+ # Note that like #type, it will still be slower than using == for a single
3697
+ # class, but should be faster in a case statement or an array comparison.
3698
+ #
3699
+ # def self.type: () -> Symbol
3700
+ def self.type
3701
+ :constant_and_write_node
3702
+ end
3489
3703
  end
3490
3704
 
3491
3705
  # Represents assigning to a constant using an operator that isn't `=`.
@@ -3586,6 +3800,16 @@ module Prism
3586
3800
  def type
3587
3801
  :constant_operator_write_node
3588
3802
  end
3803
+
3804
+ # Similar to #type, this method returns a symbol that you can use for
3805
+ # splitting on the type of the node without having to do a long === chain.
3806
+ # Note that like #type, it will still be slower than using == for a single
3807
+ # class, but should be faster in a case statement or an array comparison.
3808
+ #
3809
+ # def self.type: () -> Symbol
3810
+ def self.type
3811
+ :constant_operator_write_node
3812
+ end
3589
3813
  end
3590
3814
 
3591
3815
  # Represents the use of the `||=` operator for assignment to a constant.
@@ -3685,6 +3909,16 @@ module Prism
3685
3909
  def type
3686
3910
  :constant_or_write_node
3687
3911
  end
3912
+
3913
+ # Similar to #type, this method returns a symbol that you can use for
3914
+ # splitting on the type of the node without having to do a long === chain.
3915
+ # Note that like #type, it will still be slower than using == for a single
3916
+ # class, but should be faster in a case statement or an array comparison.
3917
+ #
3918
+ # def self.type: () -> Symbol
3919
+ def self.type
3920
+ :constant_or_write_node
3921
+ end
3688
3922
  end
3689
3923
 
3690
3924
  # Represents the use of the `&&=` operator for assignment to a constant path.
@@ -3779,6 +4013,16 @@ module Prism
3779
4013
  def type
3780
4014
  :constant_path_and_write_node
3781
4015
  end
4016
+
4017
+ # Similar to #type, this method returns a symbol that you can use for
4018
+ # splitting on the type of the node without having to do a long === chain.
4019
+ # Note that like #type, it will still be slower than using == for a single
4020
+ # class, but should be faster in a case statement or an array comparison.
4021
+ #
4022
+ # def self.type: () -> Symbol
4023
+ def self.type
4024
+ :constant_path_and_write_node
4025
+ end
3782
4026
  end
3783
4027
 
3784
4028
  # Represents accessing a constant through a path of `::` operators.
@@ -3880,6 +4124,16 @@ module Prism
3880
4124
  def type
3881
4125
  :constant_path_node
3882
4126
  end
4127
+
4128
+ # Similar to #type, this method returns a symbol that you can use for
4129
+ # splitting on the type of the node without having to do a long === chain.
4130
+ # Note that like #type, it will still be slower than using == for a single
4131
+ # class, but should be faster in a case statement or an array comparison.
4132
+ #
4133
+ # def self.type: () -> Symbol
4134
+ def self.type
4135
+ :constant_path_node
4136
+ end
3883
4137
  end
3884
4138
 
3885
4139
  # Represents assigning to a constant path using an operator that isn't `=`.
@@ -3975,7 +4229,17 @@ module Prism
3975
4229
  def type
3976
4230
  :constant_path_operator_write_node
3977
4231
  end
3978
- end
4232
+
4233
+ # Similar to #type, this method returns a symbol that you can use for
4234
+ # splitting on the type of the node without having to do a long === chain.
4235
+ # Note that like #type, it will still be slower than using == for a single
4236
+ # class, but should be faster in a case statement or an array comparison.
4237
+ #
4238
+ # def self.type: () -> Symbol
4239
+ def self.type
4240
+ :constant_path_operator_write_node
4241
+ end
4242
+ end
3979
4243
 
3980
4244
  # Represents the use of the `||=` operator for assignment to a constant path.
3981
4245
  #
@@ -4069,6 +4333,16 @@ module Prism
4069
4333
  def type
4070
4334
  :constant_path_or_write_node
4071
4335
  end
4336
+
4337
+ # Similar to #type, this method returns a symbol that you can use for
4338
+ # splitting on the type of the node without having to do a long === chain.
4339
+ # Note that like #type, it will still be slower than using == for a single
4340
+ # class, but should be faster in a case statement or an array comparison.
4341
+ #
4342
+ # def self.type: () -> Symbol
4343
+ def self.type
4344
+ :constant_path_or_write_node
4345
+ end
4072
4346
  end
4073
4347
 
4074
4348
  # Represents writing to a constant path in a context that doesn't have an explicit value.
@@ -4170,6 +4444,16 @@ module Prism
4170
4444
  def type
4171
4445
  :constant_path_target_node
4172
4446
  end
4447
+
4448
+ # Similar to #type, this method returns a symbol that you can use for
4449
+ # splitting on the type of the node without having to do a long === chain.
4450
+ # Note that like #type, it will still be slower than using == for a single
4451
+ # class, but should be faster in a case statement or an array comparison.
4452
+ #
4453
+ # def self.type: () -> Symbol
4454
+ def self.type
4455
+ :constant_path_target_node
4456
+ end
4173
4457
  end
4174
4458
 
4175
4459
  # Represents writing to a constant path.
@@ -4270,6 +4554,16 @@ module Prism
4270
4554
  def type
4271
4555
  :constant_path_write_node
4272
4556
  end
4557
+
4558
+ # Similar to #type, this method returns a symbol that you can use for
4559
+ # splitting on the type of the node without having to do a long === chain.
4560
+ # Note that like #type, it will still be slower than using == for a single
4561
+ # class, but should be faster in a case statement or an array comparison.
4562
+ #
4563
+ # def self.type: () -> Symbol
4564
+ def self.type
4565
+ :constant_path_write_node
4566
+ end
4273
4567
  end
4274
4568
 
4275
4569
  # Represents referencing a constant.
@@ -4345,6 +4639,16 @@ module Prism
4345
4639
  def type
4346
4640
  :constant_read_node
4347
4641
  end
4642
+
4643
+ # Similar to #type, this method returns a symbol that you can use for
4644
+ # splitting on the type of the node without having to do a long === chain.
4645
+ # Note that like #type, it will still be slower than using == for a single
4646
+ # class, but should be faster in a case statement or an array comparison.
4647
+ #
4648
+ # def self.type: () -> Symbol
4649
+ def self.type
4650
+ :constant_read_node
4651
+ end
4348
4652
  end
4349
4653
 
4350
4654
  # Represents writing to a constant in a context that doesn't have an explicit value.
@@ -4420,6 +4724,16 @@ module Prism
4420
4724
  def type
4421
4725
  :constant_target_node
4422
4726
  end
4727
+
4728
+ # Similar to #type, this method returns a symbol that you can use for
4729
+ # splitting on the type of the node without having to do a long === chain.
4730
+ # Note that like #type, it will still be slower than using == for a single
4731
+ # class, but should be faster in a case statement or an array comparison.
4732
+ #
4733
+ # def self.type: () -> Symbol
4734
+ def self.type
4735
+ :constant_target_node
4736
+ end
4423
4737
  end
4424
4738
 
4425
4739
  # Represents writing to a constant.
@@ -4519,6 +4833,16 @@ module Prism
4519
4833
  def type
4520
4834
  :constant_write_node
4521
4835
  end
4836
+
4837
+ # Similar to #type, this method returns a symbol that you can use for
4838
+ # splitting on the type of the node without having to do a long === chain.
4839
+ # Note that like #type, it will still be slower than using == for a single
4840
+ # class, but should be faster in a case statement or an array comparison.
4841
+ #
4842
+ # def self.type: () -> Symbol
4843
+ def self.type
4844
+ :constant_write_node
4845
+ end
4522
4846
  end
4523
4847
 
4524
4848
  # Represents a method definition.
@@ -4710,6 +5034,16 @@ module Prism
4710
5034
  def type
4711
5035
  :def_node
4712
5036
  end
5037
+
5038
+ # Similar to #type, this method returns a symbol that you can use for
5039
+ # splitting on the type of the node without having to do a long === chain.
5040
+ # Note that like #type, it will still be slower than using == for a single
5041
+ # class, but should be faster in a case statement or an array comparison.
5042
+ #
5043
+ # def self.type: () -> Symbol
5044
+ def self.type
5045
+ :def_node
5046
+ end
4713
5047
  end
4714
5048
 
4715
5049
  # Represents the use of the `defined?` keyword.
@@ -4819,6 +5153,16 @@ module Prism
4819
5153
  def type
4820
5154
  :defined_node
4821
5155
  end
5156
+
5157
+ # Similar to #type, this method returns a symbol that you can use for
5158
+ # splitting on the type of the node without having to do a long === chain.
5159
+ # Note that like #type, it will still be slower than using == for a single
5160
+ # class, but should be faster in a case statement or an array comparison.
5161
+ #
5162
+ # def self.type: () -> Symbol
5163
+ def self.type
5164
+ :defined_node
5165
+ end
4822
5166
  end
4823
5167
 
4824
5168
  # Represents an `else` clause in a `case`, `if`, or `unless` statement.
@@ -4923,6 +5267,16 @@ module Prism
4923
5267
  def type
4924
5268
  :else_node
4925
5269
  end
5270
+
5271
+ # Similar to #type, this method returns a symbol that you can use for
5272
+ # splitting on the type of the node without having to do a long === chain.
5273
+ # Note that like #type, it will still be slower than using == for a single
5274
+ # class, but should be faster in a case statement or an array comparison.
5275
+ #
5276
+ # def self.type: () -> Symbol
5277
+ def self.type
5278
+ :else_node
5279
+ end
4926
5280
  end
4927
5281
 
4928
5282
  # Represents an interpolated set of statements.
@@ -5027,6 +5381,16 @@ module Prism
5027
5381
  def type
5028
5382
  :embedded_statements_node
5029
5383
  end
5384
+
5385
+ # Similar to #type, this method returns a symbol that you can use for
5386
+ # splitting on the type of the node without having to do a long === chain.
5387
+ # Note that like #type, it will still be slower than using == for a single
5388
+ # class, but should be faster in a case statement or an array comparison.
5389
+ #
5390
+ # def self.type: () -> Symbol
5391
+ def self.type
5392
+ :embedded_statements_node
5393
+ end
5030
5394
  end
5031
5395
 
5032
5396
  # Represents an interpolated variable.
@@ -5114,6 +5478,16 @@ module Prism
5114
5478
  def type
5115
5479
  :embedded_variable_node
5116
5480
  end
5481
+
5482
+ # Similar to #type, this method returns a symbol that you can use for
5483
+ # splitting on the type of the node without having to do a long === chain.
5484
+ # Note that like #type, it will still be slower than using == for a single
5485
+ # class, but should be faster in a case statement or an array comparison.
5486
+ #
5487
+ # def self.type: () -> Symbol
5488
+ def self.type
5489
+ :embedded_variable_node
5490
+ end
5117
5491
  end
5118
5492
 
5119
5493
  # Represents an `ensure` clause in a `begin` statement.
@@ -5222,6 +5596,16 @@ module Prism
5222
5596
  def type
5223
5597
  :ensure_node
5224
5598
  end
5599
+
5600
+ # Similar to #type, this method returns a symbol that you can use for
5601
+ # splitting on the type of the node without having to do a long === chain.
5602
+ # Note that like #type, it will still be slower than using == for a single
5603
+ # class, but should be faster in a case statement or an array comparison.
5604
+ #
5605
+ # def self.type: () -> Symbol
5606
+ def self.type
5607
+ :ensure_node
5608
+ end
5225
5609
  end
5226
5610
 
5227
5611
  # Represents the use of the literal `false` keyword.
@@ -5291,6 +5675,16 @@ module Prism
5291
5675
  def type
5292
5676
  :false_node
5293
5677
  end
5678
+
5679
+ # Similar to #type, this method returns a symbol that you can use for
5680
+ # splitting on the type of the node without having to do a long === chain.
5681
+ # Note that like #type, it will still be slower than using == for a single
5682
+ # class, but should be faster in a case statement or an array comparison.
5683
+ #
5684
+ # def self.type: () -> Symbol
5685
+ def self.type
5686
+ :false_node
5687
+ end
5294
5688
  end
5295
5689
 
5296
5690
  # Represents a find pattern in pattern matching.
@@ -5424,6 +5818,16 @@ module Prism
5424
5818
  def type
5425
5819
  :find_pattern_node
5426
5820
  end
5821
+
5822
+ # Similar to #type, this method returns a symbol that you can use for
5823
+ # splitting on the type of the node without having to do a long === chain.
5824
+ # Note that like #type, it will still be slower than using == for a single
5825
+ # class, but should be faster in a case statement or an array comparison.
5826
+ #
5827
+ # def self.type: () -> Symbol
5828
+ def self.type
5829
+ :find_pattern_node
5830
+ end
5427
5831
  end
5428
5832
 
5429
5833
  # Represents the use of the `..` or `...` operators to create flip flops.
@@ -5541,6 +5945,16 @@ module Prism
5541
5945
  def type
5542
5946
  :flip_flop_node
5543
5947
  end
5948
+
5949
+ # Similar to #type, this method returns a symbol that you can use for
5950
+ # splitting on the type of the node without having to do a long === chain.
5951
+ # Note that like #type, it will still be slower than using == for a single
5952
+ # class, but should be faster in a case statement or an array comparison.
5953
+ #
5954
+ # def self.type: () -> Symbol
5955
+ def self.type
5956
+ :flip_flop_node
5957
+ end
5544
5958
  end
5545
5959
 
5546
5960
  # Represents a floating point number literal.
@@ -5610,6 +6024,16 @@ module Prism
5610
6024
  def type
5611
6025
  :float_node
5612
6026
  end
6027
+
6028
+ # Similar to #type, this method returns a symbol that you can use for
6029
+ # splitting on the type of the node without having to do a long === chain.
6030
+ # Note that like #type, it will still be slower than using == for a single
6031
+ # class, but should be faster in a case statement or an array comparison.
6032
+ #
6033
+ # def self.type: () -> Symbol
6034
+ def self.type
6035
+ :float_node
6036
+ end
5613
6037
  end
5614
6038
 
5615
6039
  # Represents the use of the `for` keyword.
@@ -5752,6 +6176,16 @@ module Prism
5752
6176
  def type
5753
6177
  :for_node
5754
6178
  end
6179
+
6180
+ # Similar to #type, this method returns a symbol that you can use for
6181
+ # splitting on the type of the node without having to do a long === chain.
6182
+ # Note that like #type, it will still be slower than using == for a single
6183
+ # class, but should be faster in a case statement or an array comparison.
6184
+ #
6185
+ # def self.type: () -> Symbol
6186
+ def self.type
6187
+ :for_node
6188
+ end
5755
6189
  end
5756
6190
 
5757
6191
  # Represents forwarding all arguments to this method to another method.
@@ -5823,6 +6257,16 @@ module Prism
5823
6257
  def type
5824
6258
  :forwarding_arguments_node
5825
6259
  end
6260
+
6261
+ # Similar to #type, this method returns a symbol that you can use for
6262
+ # splitting on the type of the node without having to do a long === chain.
6263
+ # Note that like #type, it will still be slower than using == for a single
6264
+ # class, but should be faster in a case statement or an array comparison.
6265
+ #
6266
+ # def self.type: () -> Symbol
6267
+ def self.type
6268
+ :forwarding_arguments_node
6269
+ end
5826
6270
  end
5827
6271
 
5828
6272
  # Represents the use of the forwarding parameter in a method, block, or lambda declaration.
@@ -5893,6 +6337,16 @@ module Prism
5893
6337
  def type
5894
6338
  :forwarding_parameter_node
5895
6339
  end
6340
+
6341
+ # Similar to #type, this method returns a symbol that you can use for
6342
+ # splitting on the type of the node without having to do a long === chain.
6343
+ # Note that like #type, it will still be slower than using == for a single
6344
+ # class, but should be faster in a case statement or an array comparison.
6345
+ #
6346
+ # def self.type: () -> Symbol
6347
+ def self.type
6348
+ :forwarding_parameter_node
6349
+ end
5896
6350
  end
5897
6351
 
5898
6352
  # Represents the use of the `super` keyword without parentheses or arguments.
@@ -5975,6 +6429,16 @@ module Prism
5975
6429
  def type
5976
6430
  :forwarding_super_node
5977
6431
  end
6432
+
6433
+ # Similar to #type, this method returns a symbol that you can use for
6434
+ # splitting on the type of the node without having to do a long === chain.
6435
+ # Note that like #type, it will still be slower than using == for a single
6436
+ # class, but should be faster in a case statement or an array comparison.
6437
+ #
6438
+ # def self.type: () -> Symbol
6439
+ def self.type
6440
+ :forwarding_super_node
6441
+ end
5978
6442
  end
5979
6443
 
5980
6444
  # Represents the use of the `&&=` operator for assignment to a global variable.
@@ -6074,6 +6538,16 @@ module Prism
6074
6538
  def type
6075
6539
  :global_variable_and_write_node
6076
6540
  end
6541
+
6542
+ # Similar to #type, this method returns a symbol that you can use for
6543
+ # splitting on the type of the node without having to do a long === chain.
6544
+ # Note that like #type, it will still be slower than using == for a single
6545
+ # class, but should be faster in a case statement or an array comparison.
6546
+ #
6547
+ # def self.type: () -> Symbol
6548
+ def self.type
6549
+ :global_variable_and_write_node
6550
+ end
6077
6551
  end
6078
6552
 
6079
6553
  # Represents assigning to a global variable using an operator that isn't `=`.
@@ -6174,6 +6648,16 @@ module Prism
6174
6648
  def type
6175
6649
  :global_variable_operator_write_node
6176
6650
  end
6651
+
6652
+ # Similar to #type, this method returns a symbol that you can use for
6653
+ # splitting on the type of the node without having to do a long === chain.
6654
+ # Note that like #type, it will still be slower than using == for a single
6655
+ # class, but should be faster in a case statement or an array comparison.
6656
+ #
6657
+ # def self.type: () -> Symbol
6658
+ def self.type
6659
+ :global_variable_operator_write_node
6660
+ end
6177
6661
  end
6178
6662
 
6179
6663
  # Represents the use of the `||=` operator for assignment to a global variable.
@@ -6273,6 +6757,16 @@ module Prism
6273
6757
  def type
6274
6758
  :global_variable_or_write_node
6275
6759
  end
6760
+
6761
+ # Similar to #type, this method returns a symbol that you can use for
6762
+ # splitting on the type of the node without having to do a long === chain.
6763
+ # Note that like #type, it will still be slower than using == for a single
6764
+ # class, but should be faster in a case statement or an array comparison.
6765
+ #
6766
+ # def self.type: () -> Symbol
6767
+ def self.type
6768
+ :global_variable_or_write_node
6769
+ end
6276
6770
  end
6277
6771
 
6278
6772
  # Represents referencing a global variable.
@@ -6348,6 +6842,16 @@ module Prism
6348
6842
  def type
6349
6843
  :global_variable_read_node
6350
6844
  end
6845
+
6846
+ # Similar to #type, this method returns a symbol that you can use for
6847
+ # splitting on the type of the node without having to do a long === chain.
6848
+ # Note that like #type, it will still be slower than using == for a single
6849
+ # class, but should be faster in a case statement or an array comparison.
6850
+ #
6851
+ # def self.type: () -> Symbol
6852
+ def self.type
6853
+ :global_variable_read_node
6854
+ end
6351
6855
  end
6352
6856
 
6353
6857
  # Represents writing to a global variable in a context that doesn't have an explicit value.
@@ -6423,6 +6927,16 @@ module Prism
6423
6927
  def type
6424
6928
  :global_variable_target_node
6425
6929
  end
6930
+
6931
+ # Similar to #type, this method returns a symbol that you can use for
6932
+ # splitting on the type of the node without having to do a long === chain.
6933
+ # Note that like #type, it will still be slower than using == for a single
6934
+ # class, but should be faster in a case statement or an array comparison.
6935
+ #
6936
+ # def self.type: () -> Symbol
6937
+ def self.type
6938
+ :global_variable_target_node
6939
+ end
6426
6940
  end
6427
6941
 
6428
6942
  # Represents writing to a global variable.
@@ -6522,6 +7036,16 @@ module Prism
6522
7036
  def type
6523
7037
  :global_variable_write_node
6524
7038
  end
7039
+
7040
+ # Similar to #type, this method returns a symbol that you can use for
7041
+ # splitting on the type of the node without having to do a long === chain.
7042
+ # Note that like #type, it will still be slower than using == for a single
7043
+ # class, but should be faster in a case statement or an array comparison.
7044
+ #
7045
+ # def self.type: () -> Symbol
7046
+ def self.type
7047
+ :global_variable_write_node
7048
+ end
6525
7049
  end
6526
7050
 
6527
7051
  # Represents a hash literal.
@@ -6619,6 +7143,16 @@ module Prism
6619
7143
  def type
6620
7144
  :hash_node
6621
7145
  end
7146
+
7147
+ # Similar to #type, this method returns a symbol that you can use for
7148
+ # splitting on the type of the node without having to do a long === chain.
7149
+ # Note that like #type, it will still be slower than using == for a single
7150
+ # class, but should be faster in a case statement or an array comparison.
7151
+ #
7152
+ # def self.type: () -> Symbol
7153
+ def self.type
7154
+ :hash_node
7155
+ end
6622
7156
  end
6623
7157
 
6624
7158
  # Represents a hash pattern in pattern matching.
@@ -6745,6 +7279,16 @@ module Prism
6745
7279
  def type
6746
7280
  :hash_pattern_node
6747
7281
  end
7282
+
7283
+ # Similar to #type, this method returns a symbol that you can use for
7284
+ # splitting on the type of the node without having to do a long === chain.
7285
+ # Note that like #type, it will still be slower than using == for a single
7286
+ # class, but should be faster in a case statement or an array comparison.
7287
+ #
7288
+ # def self.type: () -> Symbol
7289
+ def self.type
7290
+ :hash_pattern_node
7291
+ end
6748
7292
  end
6749
7293
 
6750
7294
  # Represents the use of the `if` keyword, either in the block form or the modifier form.
@@ -6876,6 +7420,16 @@ module Prism
6876
7420
  def type
6877
7421
  :if_node
6878
7422
  end
7423
+
7424
+ # Similar to #type, this method returns a symbol that you can use for
7425
+ # splitting on the type of the node without having to do a long === chain.
7426
+ # Note that like #type, it will still be slower than using == for a single
7427
+ # class, but should be faster in a case statement or an array comparison.
7428
+ #
7429
+ # def self.type: () -> Symbol
7430
+ def self.type
7431
+ :if_node
7432
+ end
6879
7433
  end
6880
7434
 
6881
7435
  # Represents an imaginary number literal.
@@ -6952,6 +7506,16 @@ module Prism
6952
7506
  def type
6953
7507
  :imaginary_node
6954
7508
  end
7509
+
7510
+ # Similar to #type, this method returns a symbol that you can use for
7511
+ # splitting on the type of the node without having to do a long === chain.
7512
+ # Note that like #type, it will still be slower than using == for a single
7513
+ # class, but should be faster in a case statement or an array comparison.
7514
+ #
7515
+ # def self.type: () -> Symbol
7516
+ def self.type
7517
+ :imaginary_node
7518
+ end
6955
7519
  end
6956
7520
 
6957
7521
  # Represents a node that is implicitly being added to the tree but doesn't
@@ -7032,6 +7596,16 @@ module Prism
7032
7596
  def type
7033
7597
  :implicit_node
7034
7598
  end
7599
+
7600
+ # Similar to #type, this method returns a symbol that you can use for
7601
+ # splitting on the type of the node without having to do a long === chain.
7602
+ # Note that like #type, it will still be slower than using == for a single
7603
+ # class, but should be faster in a case statement or an array comparison.
7604
+ #
7605
+ # def self.type: () -> Symbol
7606
+ def self.type
7607
+ :implicit_node
7608
+ end
7035
7609
  end
7036
7610
 
7037
7611
  # Represents the use of the `in` keyword in a case statement.
@@ -7144,18 +7718,43 @@ module Prism
7144
7718
  def type
7145
7719
  :in_node
7146
7720
  end
7721
+
7722
+ # Similar to #type, this method returns a symbol that you can use for
7723
+ # splitting on the type of the node without having to do a long === chain.
7724
+ # Note that like #type, it will still be slower than using == for a single
7725
+ # class, but should be faster in a case statement or an array comparison.
7726
+ #
7727
+ # def self.type: () -> Symbol
7728
+ def self.type
7729
+ :in_node
7730
+ end
7147
7731
  end
7148
7732
 
7149
- # Represents the use of the `&&=` operator for assignment to an instance variable.
7733
+ # Represents the use of the `&&=` operator on a call to the `[]` method.
7150
7734
  #
7151
- # @target &&= value
7152
- # ^^^^^^^^^^^^^^^^^
7153
- class InstanceVariableAndWriteNode < Node
7154
- # attr_reader name: Symbol
7155
- attr_reader :name
7735
+ # foo.bar[baz] &&= value
7736
+ # ^^^^^^^^^^^^^^^^^^^^^^
7737
+ class IndexAndWriteNode < Node
7738
+ # attr_reader receiver: Node?
7739
+ attr_reader :receiver
7156
7740
 
7157
- # attr_reader name_loc: Location
7158
- attr_reader :name_loc
7741
+ # attr_reader call_operator_loc: Location?
7742
+ attr_reader :call_operator_loc
7743
+
7744
+ # attr_reader opening_loc: Location
7745
+ attr_reader :opening_loc
7746
+
7747
+ # attr_reader arguments: ArgumentsNode?
7748
+ attr_reader :arguments
7749
+
7750
+ # attr_reader closing_loc: Location
7751
+ attr_reader :closing_loc
7752
+
7753
+ # attr_reader block: Node?
7754
+ attr_reader :block
7755
+
7756
+ # attr_reader flags: Integer
7757
+ private attr_reader :flags
7159
7758
 
7160
7759
  # attr_reader operator_loc: Location
7161
7760
  attr_reader :operator_loc
@@ -7163,10 +7762,15 @@ module Prism
7163
7762
  # attr_reader value: Node
7164
7763
  attr_reader :value
7165
7764
 
7166
- # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
7167
- def initialize(name, name_loc, operator_loc, value, location)
7168
- @name = name
7169
- @name_loc = name_loc
7765
+ # def initialize: (receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, flags: Integer, operator_loc: Location, value: Node, location: Location) -> void
7766
+ def initialize(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator_loc, value, location)
7767
+ @receiver = receiver
7768
+ @call_operator_loc = call_operator_loc
7769
+ @opening_loc = opening_loc
7770
+ @arguments = arguments
7771
+ @closing_loc = closing_loc
7772
+ @block = block
7773
+ @flags = flags
7170
7774
  @operator_loc = operator_loc
7171
7775
  @value = value
7172
7776
  @location = location
@@ -7174,29 +7778,39 @@ module Prism
7174
7778
 
7175
7779
  # def accept: (visitor: Visitor) -> void
7176
7780
  def accept(visitor)
7177
- visitor.visit_instance_variable_and_write_node(self)
7781
+ visitor.visit_index_and_write_node(self)
7178
7782
  end
7179
7783
 
7180
7784
  # def child_nodes: () -> Array[nil | Node]
7181
7785
  def child_nodes
7182
- [value]
7786
+ [receiver, arguments, block, value]
7183
7787
  end
7184
7788
 
7185
7789
  # def compact_child_nodes: () -> Array[Node]
7186
7790
  def compact_child_nodes
7187
- [value]
7791
+ compact = []
7792
+ compact << receiver if receiver
7793
+ compact << arguments if arguments
7794
+ compact << block if block
7795
+ compact << value
7796
+ compact
7188
7797
  end
7189
7798
 
7190
7799
  # def comment_targets: () -> Array[Node | Location]
7191
7800
  def comment_targets
7192
- [name_loc, operator_loc, value]
7801
+ [*receiver, *call_operator_loc, opening_loc, *arguments, closing_loc, *block, operator_loc, value]
7193
7802
  end
7194
7803
 
7195
- # def copy: (**params) -> InstanceVariableAndWriteNode
7804
+ # def copy: (**params) -> IndexAndWriteNode
7196
7805
  def copy(**params)
7197
- InstanceVariableAndWriteNode.new(
7198
- params.fetch(:name) { name },
7199
- params.fetch(:name_loc) { name_loc },
7806
+ IndexAndWriteNode.new(
7807
+ params.fetch(:receiver) { receiver },
7808
+ params.fetch(:call_operator_loc) { call_operator_loc },
7809
+ params.fetch(:opening_loc) { opening_loc },
7810
+ params.fetch(:arguments) { arguments },
7811
+ params.fetch(:closing_loc) { closing_loc },
7812
+ params.fetch(:block) { block },
7813
+ params.fetch(:flags) { flags },
7200
7814
  params.fetch(:operator_loc) { operator_loc },
7201
7815
  params.fetch(:value) { value },
7202
7816
  params.fetch(:location) { location },
@@ -7208,7 +7822,32 @@ module Prism
7208
7822
 
7209
7823
  # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
7210
7824
  def deconstruct_keys(keys)
7211
- { name: name, name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
7825
+ { receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, flags: flags, operator_loc: operator_loc, value: value, location: location }
7826
+ end
7827
+
7828
+ # def call_operator: () -> String?
7829
+ def call_operator
7830
+ call_operator_loc&.slice
7831
+ end
7832
+
7833
+ # def opening: () -> String
7834
+ def opening
7835
+ opening_loc.slice
7836
+ end
7837
+
7838
+ # def closing: () -> String
7839
+ def closing
7840
+ closing_loc.slice
7841
+ end
7842
+
7843
+ # def safe_navigation?: () -> bool
7844
+ def safe_navigation?
7845
+ flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
7846
+ end
7847
+
7848
+ # def variable_call?: () -> bool
7849
+ def variable_call?
7850
+ flags.anybits?(CallNodeFlags::VARIABLE_CALL)
7212
7851
  end
7213
7852
 
7214
7853
  # def operator: () -> String
@@ -7218,8 +7857,29 @@ module Prism
7218
7857
 
7219
7858
  def inspect(inspector = NodeInspector.new)
7220
7859
  inspector << inspector.header(self)
7221
- inspector << "├── name: #{name.inspect}\n"
7222
- inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
7860
+ if (receiver = self.receiver).nil?
7861
+ inspector << "├── receiver: ∅\n"
7862
+ else
7863
+ inspector << "├── receiver:\n"
7864
+ inspector << receiver.inspect(inspector.child_inspector("│ ")).delete_prefix(inspector.prefix)
7865
+ end
7866
+ inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
7867
+ inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
7868
+ if (arguments = self.arguments).nil?
7869
+ inspector << "├── arguments: ∅\n"
7870
+ else
7871
+ inspector << "├── arguments:\n"
7872
+ inspector << arguments.inspect(inspector.child_inspector("│ ")).delete_prefix(inspector.prefix)
7873
+ end
7874
+ inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
7875
+ if (block = self.block).nil?
7876
+ inspector << "├── block: ∅\n"
7877
+ else
7878
+ inspector << "├── block:\n"
7879
+ inspector << block.inspect(inspector.child_inspector("│ ")).delete_prefix(inspector.prefix)
7880
+ end
7881
+ flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
7882
+ inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
7223
7883
  inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
7224
7884
  inspector << "└── value:\n"
7225
7885
  inspector << inspector.child_node(value, " ")
@@ -7241,17 +7901,507 @@ module Prism
7241
7901
  #
7242
7902
  # def type: () -> Symbol
7243
7903
  def type
7244
- :instance_variable_and_write_node
7904
+ :index_and_write_node
7905
+ end
7906
+
7907
+ # Similar to #type, this method returns a symbol that you can use for
7908
+ # splitting on the type of the node without having to do a long === chain.
7909
+ # Note that like #type, it will still be slower than using == for a single
7910
+ # class, but should be faster in a case statement or an array comparison.
7911
+ #
7912
+ # def self.type: () -> Symbol
7913
+ def self.type
7914
+ :index_and_write_node
7245
7915
  end
7246
7916
  end
7247
7917
 
7248
- # Represents assigning to an instance variable using an operator that isn't `=`.
7918
+ # Represents the use of an assignment operator on a call to `[]`.
7249
7919
  #
7250
- # @target += value
7251
- # ^^^^^^^^^^^^^^^^
7252
- class InstanceVariableOperatorWriteNode < Node
7253
- # attr_reader name: Symbol
7254
- attr_reader :name
7920
+ # foo.bar[baz] += value
7921
+ # ^^^^^^^^^^^^^^^^^^^^^
7922
+ class IndexOperatorWriteNode < Node
7923
+ # attr_reader receiver: Node?
7924
+ attr_reader :receiver
7925
+
7926
+ # attr_reader call_operator_loc: Location?
7927
+ attr_reader :call_operator_loc
7928
+
7929
+ # attr_reader opening_loc: Location
7930
+ attr_reader :opening_loc
7931
+
7932
+ # attr_reader arguments: ArgumentsNode?
7933
+ attr_reader :arguments
7934
+
7935
+ # attr_reader closing_loc: Location
7936
+ attr_reader :closing_loc
7937
+
7938
+ # attr_reader block: Node?
7939
+ attr_reader :block
7940
+
7941
+ # attr_reader flags: Integer
7942
+ private attr_reader :flags
7943
+
7944
+ # attr_reader operator: Symbol
7945
+ attr_reader :operator
7946
+
7947
+ # attr_reader operator_loc: Location
7948
+ attr_reader :operator_loc
7949
+
7950
+ # attr_reader value: Node
7951
+ attr_reader :value
7952
+
7953
+ # def initialize: (receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, flags: Integer, operator: Symbol, operator_loc: Location, value: Node, location: Location) -> void
7954
+ def initialize(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator, operator_loc, value, location)
7955
+ @receiver = receiver
7956
+ @call_operator_loc = call_operator_loc
7957
+ @opening_loc = opening_loc
7958
+ @arguments = arguments
7959
+ @closing_loc = closing_loc
7960
+ @block = block
7961
+ @flags = flags
7962
+ @operator = operator
7963
+ @operator_loc = operator_loc
7964
+ @value = value
7965
+ @location = location
7966
+ end
7967
+
7968
+ # def accept: (visitor: Visitor) -> void
7969
+ def accept(visitor)
7970
+ visitor.visit_index_operator_write_node(self)
7971
+ end
7972
+
7973
+ # def child_nodes: () -> Array[nil | Node]
7974
+ def child_nodes
7975
+ [receiver, arguments, block, value]
7976
+ end
7977
+
7978
+ # def compact_child_nodes: () -> Array[Node]
7979
+ def compact_child_nodes
7980
+ compact = []
7981
+ compact << receiver if receiver
7982
+ compact << arguments if arguments
7983
+ compact << block if block
7984
+ compact << value
7985
+ compact
7986
+ end
7987
+
7988
+ # def comment_targets: () -> Array[Node | Location]
7989
+ def comment_targets
7990
+ [*receiver, *call_operator_loc, opening_loc, *arguments, closing_loc, *block, operator_loc, value]
7991
+ end
7992
+
7993
+ # def copy: (**params) -> IndexOperatorWriteNode
7994
+ def copy(**params)
7995
+ IndexOperatorWriteNode.new(
7996
+ params.fetch(:receiver) { receiver },
7997
+ params.fetch(:call_operator_loc) { call_operator_loc },
7998
+ params.fetch(:opening_loc) { opening_loc },
7999
+ params.fetch(:arguments) { arguments },
8000
+ params.fetch(:closing_loc) { closing_loc },
8001
+ params.fetch(:block) { block },
8002
+ params.fetch(:flags) { flags },
8003
+ params.fetch(:operator) { operator },
8004
+ params.fetch(:operator_loc) { operator_loc },
8005
+ params.fetch(:value) { value },
8006
+ params.fetch(:location) { location },
8007
+ )
8008
+ end
8009
+
8010
+ # def deconstruct: () -> Array[nil | Node]
8011
+ alias deconstruct child_nodes
8012
+
8013
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
8014
+ def deconstruct_keys(keys)
8015
+ { receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, flags: flags, operator: operator, operator_loc: operator_loc, value: value, location: location }
8016
+ end
8017
+
8018
+ # def call_operator: () -> String?
8019
+ def call_operator
8020
+ call_operator_loc&.slice
8021
+ end
8022
+
8023
+ # def opening: () -> String
8024
+ def opening
8025
+ opening_loc.slice
8026
+ end
8027
+
8028
+ # def closing: () -> String
8029
+ def closing
8030
+ closing_loc.slice
8031
+ end
8032
+
8033
+ # def safe_navigation?: () -> bool
8034
+ def safe_navigation?
8035
+ flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
8036
+ end
8037
+
8038
+ # def variable_call?: () -> bool
8039
+ def variable_call?
8040
+ flags.anybits?(CallNodeFlags::VARIABLE_CALL)
8041
+ end
8042
+
8043
+ def inspect(inspector = NodeInspector.new)
8044
+ inspector << inspector.header(self)
8045
+ if (receiver = self.receiver).nil?
8046
+ inspector << "├── receiver: ∅\n"
8047
+ else
8048
+ inspector << "├── receiver:\n"
8049
+ inspector << receiver.inspect(inspector.child_inspector("│ ")).delete_prefix(inspector.prefix)
8050
+ end
8051
+ inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
8052
+ inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
8053
+ if (arguments = self.arguments).nil?
8054
+ inspector << "├── arguments: ∅\n"
8055
+ else
8056
+ inspector << "├── arguments:\n"
8057
+ inspector << arguments.inspect(inspector.child_inspector("│ ")).delete_prefix(inspector.prefix)
8058
+ end
8059
+ inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
8060
+ if (block = self.block).nil?
8061
+ inspector << "├── block: ∅\n"
8062
+ else
8063
+ inspector << "├── block:\n"
8064
+ inspector << block.inspect(inspector.child_inspector("│ ")).delete_prefix(inspector.prefix)
8065
+ end
8066
+ flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
8067
+ inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
8068
+ inspector << "├── operator: #{operator.inspect}\n"
8069
+ inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
8070
+ inspector << "└── value:\n"
8071
+ inspector << inspector.child_node(value, " ")
8072
+ inspector.to_str
8073
+ end
8074
+
8075
+ # Sometimes you want to check an instance of a node against a list of
8076
+ # classes to see what kind of behavior to perform. Usually this is done by
8077
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
8078
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
8079
+ # these approaches are relatively slow because of the constant lookups,
8080
+ # method calls, and/or array allocations.
8081
+ #
8082
+ # Instead, you can call #type, which will return to you a symbol that you
8083
+ # can use for comparison. This is faster than the other approaches because
8084
+ # it uses a single integer comparison, but also because if you're on CRuby
8085
+ # you can take advantage of the fact that case statements with all symbol
8086
+ # keys will use a jump table.
8087
+ #
8088
+ # def type: () -> Symbol
8089
+ def type
8090
+ :index_operator_write_node
8091
+ end
8092
+
8093
+ # Similar to #type, this method returns a symbol that you can use for
8094
+ # splitting on the type of the node without having to do a long === chain.
8095
+ # Note that like #type, it will still be slower than using == for a single
8096
+ # class, but should be faster in a case statement or an array comparison.
8097
+ #
8098
+ # def self.type: () -> Symbol
8099
+ def self.type
8100
+ :index_operator_write_node
8101
+ end
8102
+ end
8103
+
8104
+ # Represents the use of the `||=` operator on a call to `[]`.
8105
+ #
8106
+ # foo.bar[baz] ||= value
8107
+ # ^^^^^^^^^^^^^^^^^^^^^^
8108
+ class IndexOrWriteNode < Node
8109
+ # attr_reader receiver: Node?
8110
+ attr_reader :receiver
8111
+
8112
+ # attr_reader call_operator_loc: Location?
8113
+ attr_reader :call_operator_loc
8114
+
8115
+ # attr_reader opening_loc: Location
8116
+ attr_reader :opening_loc
8117
+
8118
+ # attr_reader arguments: ArgumentsNode?
8119
+ attr_reader :arguments
8120
+
8121
+ # attr_reader closing_loc: Location
8122
+ attr_reader :closing_loc
8123
+
8124
+ # attr_reader block: Node?
8125
+ attr_reader :block
8126
+
8127
+ # attr_reader flags: Integer
8128
+ private attr_reader :flags
8129
+
8130
+ # attr_reader operator_loc: Location
8131
+ attr_reader :operator_loc
8132
+
8133
+ # attr_reader value: Node
8134
+ attr_reader :value
8135
+
8136
+ # def initialize: (receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, flags: Integer, operator_loc: Location, value: Node, location: Location) -> void
8137
+ def initialize(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator_loc, value, location)
8138
+ @receiver = receiver
8139
+ @call_operator_loc = call_operator_loc
8140
+ @opening_loc = opening_loc
8141
+ @arguments = arguments
8142
+ @closing_loc = closing_loc
8143
+ @block = block
8144
+ @flags = flags
8145
+ @operator_loc = operator_loc
8146
+ @value = value
8147
+ @location = location
8148
+ end
8149
+
8150
+ # def accept: (visitor: Visitor) -> void
8151
+ def accept(visitor)
8152
+ visitor.visit_index_or_write_node(self)
8153
+ end
8154
+
8155
+ # def child_nodes: () -> Array[nil | Node]
8156
+ def child_nodes
8157
+ [receiver, arguments, block, value]
8158
+ end
8159
+
8160
+ # def compact_child_nodes: () -> Array[Node]
8161
+ def compact_child_nodes
8162
+ compact = []
8163
+ compact << receiver if receiver
8164
+ compact << arguments if arguments
8165
+ compact << block if block
8166
+ compact << value
8167
+ compact
8168
+ end
8169
+
8170
+ # def comment_targets: () -> Array[Node | Location]
8171
+ def comment_targets
8172
+ [*receiver, *call_operator_loc, opening_loc, *arguments, closing_loc, *block, operator_loc, value]
8173
+ end
8174
+
8175
+ # def copy: (**params) -> IndexOrWriteNode
8176
+ def copy(**params)
8177
+ IndexOrWriteNode.new(
8178
+ params.fetch(:receiver) { receiver },
8179
+ params.fetch(:call_operator_loc) { call_operator_loc },
8180
+ params.fetch(:opening_loc) { opening_loc },
8181
+ params.fetch(:arguments) { arguments },
8182
+ params.fetch(:closing_loc) { closing_loc },
8183
+ params.fetch(:block) { block },
8184
+ params.fetch(:flags) { flags },
8185
+ params.fetch(:operator_loc) { operator_loc },
8186
+ params.fetch(:value) { value },
8187
+ params.fetch(:location) { location },
8188
+ )
8189
+ end
8190
+
8191
+ # def deconstruct: () -> Array[nil | Node]
8192
+ alias deconstruct child_nodes
8193
+
8194
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
8195
+ def deconstruct_keys(keys)
8196
+ { receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, flags: flags, operator_loc: operator_loc, value: value, location: location }
8197
+ end
8198
+
8199
+ # def call_operator: () -> String?
8200
+ def call_operator
8201
+ call_operator_loc&.slice
8202
+ end
8203
+
8204
+ # def opening: () -> String
8205
+ def opening
8206
+ opening_loc.slice
8207
+ end
8208
+
8209
+ # def closing: () -> String
8210
+ def closing
8211
+ closing_loc.slice
8212
+ end
8213
+
8214
+ # def safe_navigation?: () -> bool
8215
+ def safe_navigation?
8216
+ flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
8217
+ end
8218
+
8219
+ # def variable_call?: () -> bool
8220
+ def variable_call?
8221
+ flags.anybits?(CallNodeFlags::VARIABLE_CALL)
8222
+ end
8223
+
8224
+ # def operator: () -> String
8225
+ def operator
8226
+ operator_loc.slice
8227
+ end
8228
+
8229
+ def inspect(inspector = NodeInspector.new)
8230
+ inspector << inspector.header(self)
8231
+ if (receiver = self.receiver).nil?
8232
+ inspector << "├── receiver: ∅\n"
8233
+ else
8234
+ inspector << "├── receiver:\n"
8235
+ inspector << receiver.inspect(inspector.child_inspector("│ ")).delete_prefix(inspector.prefix)
8236
+ end
8237
+ inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
8238
+ inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
8239
+ if (arguments = self.arguments).nil?
8240
+ inspector << "├── arguments: ∅\n"
8241
+ else
8242
+ inspector << "├── arguments:\n"
8243
+ inspector << arguments.inspect(inspector.child_inspector("│ ")).delete_prefix(inspector.prefix)
8244
+ end
8245
+ inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
8246
+ if (block = self.block).nil?
8247
+ inspector << "├── block: ∅\n"
8248
+ else
8249
+ inspector << "├── block:\n"
8250
+ inspector << block.inspect(inspector.child_inspector("│ ")).delete_prefix(inspector.prefix)
8251
+ end
8252
+ flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
8253
+ inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
8254
+ inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
8255
+ inspector << "└── value:\n"
8256
+ inspector << inspector.child_node(value, " ")
8257
+ inspector.to_str
8258
+ end
8259
+
8260
+ # Sometimes you want to check an instance of a node against a list of
8261
+ # classes to see what kind of behavior to perform. Usually this is done by
8262
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
8263
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
8264
+ # these approaches are relatively slow because of the constant lookups,
8265
+ # method calls, and/or array allocations.
8266
+ #
8267
+ # Instead, you can call #type, which will return to you a symbol that you
8268
+ # can use for comparison. This is faster than the other approaches because
8269
+ # it uses a single integer comparison, but also because if you're on CRuby
8270
+ # you can take advantage of the fact that case statements with all symbol
8271
+ # keys will use a jump table.
8272
+ #
8273
+ # def type: () -> Symbol
8274
+ def type
8275
+ :index_or_write_node
8276
+ end
8277
+
8278
+ # Similar to #type, this method returns a symbol that you can use for
8279
+ # splitting on the type of the node without having to do a long === chain.
8280
+ # Note that like #type, it will still be slower than using == for a single
8281
+ # class, but should be faster in a case statement or an array comparison.
8282
+ #
8283
+ # def self.type: () -> Symbol
8284
+ def self.type
8285
+ :index_or_write_node
8286
+ end
8287
+ end
8288
+
8289
+ # Represents the use of the `&&=` operator for assignment to an instance variable.
8290
+ #
8291
+ # @target &&= value
8292
+ # ^^^^^^^^^^^^^^^^^
8293
+ class InstanceVariableAndWriteNode < Node
8294
+ # attr_reader name: Symbol
8295
+ attr_reader :name
8296
+
8297
+ # attr_reader name_loc: Location
8298
+ attr_reader :name_loc
8299
+
8300
+ # attr_reader operator_loc: Location
8301
+ attr_reader :operator_loc
8302
+
8303
+ # attr_reader value: Node
8304
+ attr_reader :value
8305
+
8306
+ # def initialize: (name: Symbol, name_loc: Location, operator_loc: Location, value: Node, location: Location) -> void
8307
+ def initialize(name, name_loc, operator_loc, value, location)
8308
+ @name = name
8309
+ @name_loc = name_loc
8310
+ @operator_loc = operator_loc
8311
+ @value = value
8312
+ @location = location
8313
+ end
8314
+
8315
+ # def accept: (visitor: Visitor) -> void
8316
+ def accept(visitor)
8317
+ visitor.visit_instance_variable_and_write_node(self)
8318
+ end
8319
+
8320
+ # def child_nodes: () -> Array[nil | Node]
8321
+ def child_nodes
8322
+ [value]
8323
+ end
8324
+
8325
+ # def compact_child_nodes: () -> Array[Node]
8326
+ def compact_child_nodes
8327
+ [value]
8328
+ end
8329
+
8330
+ # def comment_targets: () -> Array[Node | Location]
8331
+ def comment_targets
8332
+ [name_loc, operator_loc, value]
8333
+ end
8334
+
8335
+ # def copy: (**params) -> InstanceVariableAndWriteNode
8336
+ def copy(**params)
8337
+ InstanceVariableAndWriteNode.new(
8338
+ params.fetch(:name) { name },
8339
+ params.fetch(:name_loc) { name_loc },
8340
+ params.fetch(:operator_loc) { operator_loc },
8341
+ params.fetch(:value) { value },
8342
+ params.fetch(:location) { location },
8343
+ )
8344
+ end
8345
+
8346
+ # def deconstruct: () -> Array[nil | Node]
8347
+ alias deconstruct child_nodes
8348
+
8349
+ # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
8350
+ def deconstruct_keys(keys)
8351
+ { name: name, name_loc: name_loc, operator_loc: operator_loc, value: value, location: location }
8352
+ end
8353
+
8354
+ # def operator: () -> String
8355
+ def operator
8356
+ operator_loc.slice
8357
+ end
8358
+
8359
+ def inspect(inspector = NodeInspector.new)
8360
+ inspector << inspector.header(self)
8361
+ inspector << "├── name: #{name.inspect}\n"
8362
+ inspector << "├── name_loc: #{inspector.location(name_loc)}\n"
8363
+ inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
8364
+ inspector << "└── value:\n"
8365
+ inspector << inspector.child_node(value, " ")
8366
+ inspector.to_str
8367
+ end
8368
+
8369
+ # Sometimes you want to check an instance of a node against a list of
8370
+ # classes to see what kind of behavior to perform. Usually this is done by
8371
+ # calling `[cls1, cls2].include?(node.class)` or putting the node into a
8372
+ # case statement and doing `case node; when cls1; when cls2; end`. Both of
8373
+ # these approaches are relatively slow because of the constant lookups,
8374
+ # method calls, and/or array allocations.
8375
+ #
8376
+ # Instead, you can call #type, which will return to you a symbol that you
8377
+ # can use for comparison. This is faster than the other approaches because
8378
+ # it uses a single integer comparison, but also because if you're on CRuby
8379
+ # you can take advantage of the fact that case statements with all symbol
8380
+ # keys will use a jump table.
8381
+ #
8382
+ # def type: () -> Symbol
8383
+ def type
8384
+ :instance_variable_and_write_node
8385
+ end
8386
+
8387
+ # Similar to #type, this method returns a symbol that you can use for
8388
+ # splitting on the type of the node without having to do a long === chain.
8389
+ # Note that like #type, it will still be slower than using == for a single
8390
+ # class, but should be faster in a case statement or an array comparison.
8391
+ #
8392
+ # def self.type: () -> Symbol
8393
+ def self.type
8394
+ :instance_variable_and_write_node
8395
+ end
8396
+ end
8397
+
8398
+ # Represents assigning to an instance variable using an operator that isn't `=`.
8399
+ #
8400
+ # @target += value
8401
+ # ^^^^^^^^^^^^^^^^
8402
+ class InstanceVariableOperatorWriteNode < Node
8403
+ # attr_reader name: Symbol
8404
+ attr_reader :name
7255
8405
 
7256
8406
  # attr_reader name_loc: Location
7257
8407
  attr_reader :name_loc
@@ -7343,6 +8493,16 @@ module Prism
7343
8493
  def type
7344
8494
  :instance_variable_operator_write_node
7345
8495
  end
8496
+
8497
+ # Similar to #type, this method returns a symbol that you can use for
8498
+ # splitting on the type of the node without having to do a long === chain.
8499
+ # Note that like #type, it will still be slower than using == for a single
8500
+ # class, but should be faster in a case statement or an array comparison.
8501
+ #
8502
+ # def self.type: () -> Symbol
8503
+ def self.type
8504
+ :instance_variable_operator_write_node
8505
+ end
7346
8506
  end
7347
8507
 
7348
8508
  # Represents the use of the `||=` operator for assignment to an instance variable.
@@ -7442,6 +8602,16 @@ module Prism
7442
8602
  def type
7443
8603
  :instance_variable_or_write_node
7444
8604
  end
8605
+
8606
+ # Similar to #type, this method returns a symbol that you can use for
8607
+ # splitting on the type of the node without having to do a long === chain.
8608
+ # Note that like #type, it will still be slower than using == for a single
8609
+ # class, but should be faster in a case statement or an array comparison.
8610
+ #
8611
+ # def self.type: () -> Symbol
8612
+ def self.type
8613
+ :instance_variable_or_write_node
8614
+ end
7445
8615
  end
7446
8616
 
7447
8617
  # Represents referencing an instance variable.
@@ -7517,6 +8687,16 @@ module Prism
7517
8687
  def type
7518
8688
  :instance_variable_read_node
7519
8689
  end
8690
+
8691
+ # Similar to #type, this method returns a symbol that you can use for
8692
+ # splitting on the type of the node without having to do a long === chain.
8693
+ # Note that like #type, it will still be slower than using == for a single
8694
+ # class, but should be faster in a case statement or an array comparison.
8695
+ #
8696
+ # def self.type: () -> Symbol
8697
+ def self.type
8698
+ :instance_variable_read_node
8699
+ end
7520
8700
  end
7521
8701
 
7522
8702
  # Represents writing to an instance variable in a context that doesn't have an explicit value.
@@ -7592,6 +8772,16 @@ module Prism
7592
8772
  def type
7593
8773
  :instance_variable_target_node
7594
8774
  end
8775
+
8776
+ # Similar to #type, this method returns a symbol that you can use for
8777
+ # splitting on the type of the node without having to do a long === chain.
8778
+ # Note that like #type, it will still be slower than using == for a single
8779
+ # class, but should be faster in a case statement or an array comparison.
8780
+ #
8781
+ # def self.type: () -> Symbol
8782
+ def self.type
8783
+ :instance_variable_target_node
8784
+ end
7595
8785
  end
7596
8786
 
7597
8787
  # Represents writing to an instance variable.
@@ -7691,6 +8881,16 @@ module Prism
7691
8881
  def type
7692
8882
  :instance_variable_write_node
7693
8883
  end
8884
+
8885
+ # Similar to #type, this method returns a symbol that you can use for
8886
+ # splitting on the type of the node without having to do a long === chain.
8887
+ # Note that like #type, it will still be slower than using == for a single
8888
+ # class, but should be faster in a case statement or an array comparison.
8889
+ #
8890
+ # def self.type: () -> Symbol
8891
+ def self.type
8892
+ :instance_variable_write_node
8893
+ end
7694
8894
  end
7695
8895
 
7696
8896
  # Represents an integer number literal.
@@ -7787,6 +8987,16 @@ module Prism
7787
8987
  def type
7788
8988
  :integer_node
7789
8989
  end
8990
+
8991
+ # Similar to #type, this method returns a symbol that you can use for
8992
+ # splitting on the type of the node without having to do a long === chain.
8993
+ # Note that like #type, it will still be slower than using == for a single
8994
+ # class, but should be faster in a case statement or an array comparison.
8995
+ #
8996
+ # def self.type: () -> Symbol
8997
+ def self.type
8998
+ :integer_node
8999
+ end
7790
9000
  end
7791
9001
 
7792
9002
  # Represents a regular expression literal that contains interpolation that
@@ -7886,6 +9096,11 @@ module Prism
7886
9096
  flags.anybits?(RegularExpressionFlags::MULTI_LINE)
7887
9097
  end
7888
9098
 
9099
+ # def once?: () -> bool
9100
+ def once?
9101
+ flags.anybits?(RegularExpressionFlags::ONCE)
9102
+ end
9103
+
7889
9104
  # def euc_jp?: () -> bool
7890
9105
  def euc_jp?
7891
9106
  flags.anybits?(RegularExpressionFlags::EUC_JP)
@@ -7906,17 +9121,12 @@ module Prism
7906
9121
  flags.anybits?(RegularExpressionFlags::UTF_8)
7907
9122
  end
7908
9123
 
7909
- # def once?: () -> bool
7910
- def once?
7911
- flags.anybits?(RegularExpressionFlags::ONCE)
7912
- end
7913
-
7914
9124
  def inspect(inspector = NodeInspector.new)
7915
9125
  inspector << inspector.header(self)
7916
9126
  inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
7917
9127
  inspector << "├── parts: #{inspector.list("#{inspector.prefix}│ ", parts)}"
7918
9128
  inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
7919
- flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?), ("once" if once?)].compact
9129
+ flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("once" if once?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?)].compact
7920
9130
  inspector << "└── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
7921
9131
  inspector.to_str
7922
9132
  end
@@ -7938,6 +9148,16 @@ module Prism
7938
9148
  def type
7939
9149
  :interpolated_match_last_line_node
7940
9150
  end
9151
+
9152
+ # Similar to #type, this method returns a symbol that you can use for
9153
+ # splitting on the type of the node without having to do a long === chain.
9154
+ # Note that like #type, it will still be slower than using == for a single
9155
+ # class, but should be faster in a case statement or an array comparison.
9156
+ #
9157
+ # def self.type: () -> Symbol
9158
+ def self.type
9159
+ :interpolated_match_last_line_node
9160
+ end
7941
9161
  end
7942
9162
 
7943
9163
  # Represents a regular expression literal that contains interpolation.
@@ -8035,6 +9255,11 @@ module Prism
8035
9255
  flags.anybits?(RegularExpressionFlags::MULTI_LINE)
8036
9256
  end
8037
9257
 
9258
+ # def once?: () -> bool
9259
+ def once?
9260
+ flags.anybits?(RegularExpressionFlags::ONCE)
9261
+ end
9262
+
8038
9263
  # def euc_jp?: () -> bool
8039
9264
  def euc_jp?
8040
9265
  flags.anybits?(RegularExpressionFlags::EUC_JP)
@@ -8055,17 +9280,12 @@ module Prism
8055
9280
  flags.anybits?(RegularExpressionFlags::UTF_8)
8056
9281
  end
8057
9282
 
8058
- # def once?: () -> bool
8059
- def once?
8060
- flags.anybits?(RegularExpressionFlags::ONCE)
8061
- end
8062
-
8063
9283
  def inspect(inspector = NodeInspector.new)
8064
9284
  inspector << inspector.header(self)
8065
9285
  inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
8066
9286
  inspector << "├── parts: #{inspector.list("#{inspector.prefix}│ ", parts)}"
8067
9287
  inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
8068
- flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?), ("once" if once?)].compact
9288
+ flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("once" if once?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?)].compact
8069
9289
  inspector << "└── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
8070
9290
  inspector.to_str
8071
9291
  end
@@ -8087,6 +9307,16 @@ module Prism
8087
9307
  def type
8088
9308
  :interpolated_regular_expression_node
8089
9309
  end
9310
+
9311
+ # Similar to #type, this method returns a symbol that you can use for
9312
+ # splitting on the type of the node without having to do a long === chain.
9313
+ # Note that like #type, it will still be slower than using == for a single
9314
+ # class, but should be faster in a case statement or an array comparison.
9315
+ #
9316
+ # def self.type: () -> Symbol
9317
+ def self.type
9318
+ :interpolated_regular_expression_node
9319
+ end
8090
9320
  end
8091
9321
 
8092
9322
  # Represents a string literal that contains interpolation.
@@ -8189,6 +9419,16 @@ module Prism
8189
9419
  def type
8190
9420
  :interpolated_string_node
8191
9421
  end
9422
+
9423
+ # Similar to #type, this method returns a symbol that you can use for
9424
+ # splitting on the type of the node without having to do a long === chain.
9425
+ # Note that like #type, it will still be slower than using == for a single
9426
+ # class, but should be faster in a case statement or an array comparison.
9427
+ #
9428
+ # def self.type: () -> Symbol
9429
+ def self.type
9430
+ :interpolated_string_node
9431
+ end
8192
9432
  end
8193
9433
 
8194
9434
  # Represents a symbol literal that contains interpolation.
@@ -8291,6 +9531,16 @@ module Prism
8291
9531
  def type
8292
9532
  :interpolated_symbol_node
8293
9533
  end
9534
+
9535
+ # Similar to #type, this method returns a symbol that you can use for
9536
+ # splitting on the type of the node without having to do a long === chain.
9537
+ # Note that like #type, it will still be slower than using == for a single
9538
+ # class, but should be faster in a case statement or an array comparison.
9539
+ #
9540
+ # def self.type: () -> Symbol
9541
+ def self.type
9542
+ :interpolated_symbol_node
9543
+ end
8294
9544
  end
8295
9545
 
8296
9546
  # Represents an xstring literal that contains interpolation.
@@ -8393,6 +9643,16 @@ module Prism
8393
9643
  def type
8394
9644
  :interpolated_x_string_node
8395
9645
  end
9646
+
9647
+ # Similar to #type, this method returns a symbol that you can use for
9648
+ # splitting on the type of the node without having to do a long === chain.
9649
+ # Note that like #type, it will still be slower than using == for a single
9650
+ # class, but should be faster in a case statement or an array comparison.
9651
+ #
9652
+ # def self.type: () -> Symbol
9653
+ def self.type
9654
+ :interpolated_x_string_node
9655
+ end
8396
9656
  end
8397
9657
 
8398
9658
  # Represents a hash literal without opening and closing braces.
@@ -8468,6 +9728,16 @@ module Prism
8468
9728
  def type
8469
9729
  :keyword_hash_node
8470
9730
  end
9731
+
9732
+ # Similar to #type, this method returns a symbol that you can use for
9733
+ # splitting on the type of the node without having to do a long === chain.
9734
+ # Note that like #type, it will still be slower than using == for a single
9735
+ # class, but should be faster in a case statement or an array comparison.
9736
+ #
9737
+ # def self.type: () -> Symbol
9738
+ def self.type
9739
+ :keyword_hash_node
9740
+ end
8471
9741
  end
8472
9742
 
8473
9743
  # Represents a keyword parameter to a method, block, or lambda definition.
@@ -8567,6 +9837,16 @@ module Prism
8567
9837
  def type
8568
9838
  :keyword_parameter_node
8569
9839
  end
9840
+
9841
+ # Similar to #type, this method returns a symbol that you can use for
9842
+ # splitting on the type of the node without having to do a long === chain.
9843
+ # Note that like #type, it will still be slower than using == for a single
9844
+ # class, but should be faster in a case statement or an array comparison.
9845
+ #
9846
+ # def self.type: () -> Symbol
9847
+ def self.type
9848
+ :keyword_parameter_node
9849
+ end
8570
9850
  end
8571
9851
 
8572
9852
  # Represents a keyword rest parameter to a method, block, or lambda definition.
@@ -8660,6 +9940,16 @@ module Prism
8660
9940
  def type
8661
9941
  :keyword_rest_parameter_node
8662
9942
  end
9943
+
9944
+ # Similar to #type, this method returns a symbol that you can use for
9945
+ # splitting on the type of the node without having to do a long === chain.
9946
+ # Note that like #type, it will still be slower than using == for a single
9947
+ # class, but should be faster in a case statement or an array comparison.
9948
+ #
9949
+ # def self.type: () -> Symbol
9950
+ def self.type
9951
+ :keyword_rest_parameter_node
9952
+ end
8663
9953
  end
8664
9954
 
8665
9955
  # Represents using a lambda literal (not the lambda method call).
@@ -8793,6 +10083,16 @@ module Prism
8793
10083
  def type
8794
10084
  :lambda_node
8795
10085
  end
10086
+
10087
+ # Similar to #type, this method returns a symbol that you can use for
10088
+ # splitting on the type of the node without having to do a long === chain.
10089
+ # Note that like #type, it will still be slower than using == for a single
10090
+ # class, but should be faster in a case statement or an array comparison.
10091
+ #
10092
+ # def self.type: () -> Symbol
10093
+ def self.type
10094
+ :lambda_node
10095
+ end
8796
10096
  end
8797
10097
 
8798
10098
  # Represents the use of the `&&=` operator for assignment to a local variable.
@@ -8898,6 +10198,16 @@ module Prism
8898
10198
  def type
8899
10199
  :local_variable_and_write_node
8900
10200
  end
10201
+
10202
+ # Similar to #type, this method returns a symbol that you can use for
10203
+ # splitting on the type of the node without having to do a long === chain.
10204
+ # Note that like #type, it will still be slower than using == for a single
10205
+ # class, but should be faster in a case statement or an array comparison.
10206
+ #
10207
+ # def self.type: () -> Symbol
10208
+ def self.type
10209
+ :local_variable_and_write_node
10210
+ end
8901
10211
  end
8902
10212
 
8903
10213
  # Represents assigning to a local variable using an operator that isn't `=`.
@@ -9004,6 +10314,16 @@ module Prism
9004
10314
  def type
9005
10315
  :local_variable_operator_write_node
9006
10316
  end
10317
+
10318
+ # Similar to #type, this method returns a symbol that you can use for
10319
+ # splitting on the type of the node without having to do a long === chain.
10320
+ # Note that like #type, it will still be slower than using == for a single
10321
+ # class, but should be faster in a case statement or an array comparison.
10322
+ #
10323
+ # def self.type: () -> Symbol
10324
+ def self.type
10325
+ :local_variable_operator_write_node
10326
+ end
9007
10327
  end
9008
10328
 
9009
10329
  # Represents the use of the `||=` operator for assignment to a local variable.
@@ -9109,6 +10429,16 @@ module Prism
9109
10429
  def type
9110
10430
  :local_variable_or_write_node
9111
10431
  end
10432
+
10433
+ # Similar to #type, this method returns a symbol that you can use for
10434
+ # splitting on the type of the node without having to do a long === chain.
10435
+ # Note that like #type, it will still be slower than using == for a single
10436
+ # class, but should be faster in a case statement or an array comparison.
10437
+ #
10438
+ # def self.type: () -> Symbol
10439
+ def self.type
10440
+ :local_variable_or_write_node
10441
+ end
9112
10442
  end
9113
10443
 
9114
10444
  # Represents reading a local variable. Note that this requires that a local
@@ -9192,6 +10522,16 @@ module Prism
9192
10522
  def type
9193
10523
  :local_variable_read_node
9194
10524
  end
10525
+
10526
+ # Similar to #type, this method returns a symbol that you can use for
10527
+ # splitting on the type of the node without having to do a long === chain.
10528
+ # Note that like #type, it will still be slower than using == for a single
10529
+ # class, but should be faster in a case statement or an array comparison.
10530
+ #
10531
+ # def self.type: () -> Symbol
10532
+ def self.type
10533
+ :local_variable_read_node
10534
+ end
9195
10535
  end
9196
10536
 
9197
10537
  # Represents writing to a local variable in a context that doesn't have an explicit value.
@@ -9273,6 +10613,16 @@ module Prism
9273
10613
  def type
9274
10614
  :local_variable_target_node
9275
10615
  end
10616
+
10617
+ # Similar to #type, this method returns a symbol that you can use for
10618
+ # splitting on the type of the node without having to do a long === chain.
10619
+ # Note that like #type, it will still be slower than using == for a single
10620
+ # class, but should be faster in a case statement or an array comparison.
10621
+ #
10622
+ # def self.type: () -> Symbol
10623
+ def self.type
10624
+ :local_variable_target_node
10625
+ end
9276
10626
  end
9277
10627
 
9278
10628
  # Represents writing to a local variable.
@@ -9378,6 +10728,16 @@ module Prism
9378
10728
  def type
9379
10729
  :local_variable_write_node
9380
10730
  end
10731
+
10732
+ # Similar to #type, this method returns a symbol that you can use for
10733
+ # splitting on the type of the node without having to do a long === chain.
10734
+ # Note that like #type, it will still be slower than using == for a single
10735
+ # class, but should be faster in a case statement or an array comparison.
10736
+ #
10737
+ # def self.type: () -> Symbol
10738
+ def self.type
10739
+ :local_variable_write_node
10740
+ end
9381
10741
  end
9382
10742
 
9383
10743
  # Represents a regular expression literal used in the predicate of a
@@ -9482,6 +10842,11 @@ module Prism
9482
10842
  flags.anybits?(RegularExpressionFlags::MULTI_LINE)
9483
10843
  end
9484
10844
 
10845
+ # def once?: () -> bool
10846
+ def once?
10847
+ flags.anybits?(RegularExpressionFlags::ONCE)
10848
+ end
10849
+
9485
10850
  # def euc_jp?: () -> bool
9486
10851
  def euc_jp?
9487
10852
  flags.anybits?(RegularExpressionFlags::EUC_JP)
@@ -9502,18 +10867,13 @@ module Prism
9502
10867
  flags.anybits?(RegularExpressionFlags::UTF_8)
9503
10868
  end
9504
10869
 
9505
- # def once?: () -> bool
9506
- def once?
9507
- flags.anybits?(RegularExpressionFlags::ONCE)
9508
- end
9509
-
9510
10870
  def inspect(inspector = NodeInspector.new)
9511
10871
  inspector << inspector.header(self)
9512
10872
  inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
9513
10873
  inspector << "├── content_loc: #{inspector.location(content_loc)}\n"
9514
10874
  inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
9515
10875
  inspector << "├── unescaped: #{unescaped.inspect}\n"
9516
- flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?), ("once" if once?)].compact
10876
+ flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("once" if once?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?)].compact
9517
10877
  inspector << "└── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
9518
10878
  inspector.to_str
9519
10879
  end
@@ -9535,6 +10895,16 @@ module Prism
9535
10895
  def type
9536
10896
  :match_last_line_node
9537
10897
  end
10898
+
10899
+ # Similar to #type, this method returns a symbol that you can use for
10900
+ # splitting on the type of the node without having to do a long === chain.
10901
+ # Note that like #type, it will still be slower than using == for a single
10902
+ # class, but should be faster in a case statement or an array comparison.
10903
+ #
10904
+ # def self.type: () -> Symbol
10905
+ def self.type
10906
+ :match_last_line_node
10907
+ end
9538
10908
  end
9539
10909
 
9540
10910
  # Represents the use of the modifier `in` operator.
@@ -9629,6 +10999,16 @@ module Prism
9629
10999
  def type
9630
11000
  :match_predicate_node
9631
11001
  end
11002
+
11003
+ # Similar to #type, this method returns a symbol that you can use for
11004
+ # splitting on the type of the node without having to do a long === chain.
11005
+ # Note that like #type, it will still be slower than using == for a single
11006
+ # class, but should be faster in a case statement or an array comparison.
11007
+ #
11008
+ # def self.type: () -> Symbol
11009
+ def self.type
11010
+ :match_predicate_node
11011
+ end
9632
11012
  end
9633
11013
 
9634
11014
  # Represents the use of the `=>` operator.
@@ -9723,6 +11103,16 @@ module Prism
9723
11103
  def type
9724
11104
  :match_required_node
9725
11105
  end
11106
+
11107
+ # Similar to #type, this method returns a symbol that you can use for
11108
+ # splitting on the type of the node without having to do a long === chain.
11109
+ # Note that like #type, it will still be slower than using == for a single
11110
+ # class, but should be faster in a case statement or an array comparison.
11111
+ #
11112
+ # def self.type: () -> Symbol
11113
+ def self.type
11114
+ :match_required_node
11115
+ end
9726
11116
  end
9727
11117
 
9728
11118
  # Represents writing local variables using a regular expression match with
@@ -9806,6 +11196,16 @@ module Prism
9806
11196
  def type
9807
11197
  :match_write_node
9808
11198
  end
11199
+
11200
+ # Similar to #type, this method returns a symbol that you can use for
11201
+ # splitting on the type of the node without having to do a long === chain.
11202
+ # Note that like #type, it will still be slower than using == for a single
11203
+ # class, but should be faster in a case statement or an array comparison.
11204
+ #
11205
+ # def self.type: () -> Symbol
11206
+ def self.type
11207
+ :match_write_node
11208
+ end
9809
11209
  end
9810
11210
 
9811
11211
  # Represents a node that is missing from the source and results in a syntax
@@ -9873,6 +11273,16 @@ module Prism
9873
11273
  def type
9874
11274
  :missing_node
9875
11275
  end
11276
+
11277
+ # Similar to #type, this method returns a symbol that you can use for
11278
+ # splitting on the type of the node without having to do a long === chain.
11279
+ # Note that like #type, it will still be slower than using == for a single
11280
+ # class, but should be faster in a case statement or an array comparison.
11281
+ #
11282
+ # def self.type: () -> Symbol
11283
+ def self.type
11284
+ :missing_node
11285
+ end
9876
11286
  end
9877
11287
 
9878
11288
  # Represents a module declaration involving the `module` keyword.
@@ -9997,6 +11407,16 @@ module Prism
9997
11407
  def type
9998
11408
  :module_node
9999
11409
  end
11410
+
11411
+ # Similar to #type, this method returns a symbol that you can use for
11412
+ # splitting on the type of the node without having to do a long === chain.
11413
+ # Note that like #type, it will still be slower than using == for a single
11414
+ # class, but should be faster in a case statement or an array comparison.
11415
+ #
11416
+ # def self.type: () -> Symbol
11417
+ def self.type
11418
+ :module_node
11419
+ end
10000
11420
  end
10001
11421
 
10002
11422
  # Represents a multi-target expression.
@@ -10094,6 +11514,16 @@ module Prism
10094
11514
  def type
10095
11515
  :multi_target_node
10096
11516
  end
11517
+
11518
+ # Similar to #type, this method returns a symbol that you can use for
11519
+ # splitting on the type of the node without having to do a long === chain.
11520
+ # Note that like #type, it will still be slower than using == for a single
11521
+ # class, but should be faster in a case statement or an array comparison.
11522
+ #
11523
+ # def self.type: () -> Symbol
11524
+ def self.type
11525
+ :multi_target_node
11526
+ end
10097
11527
  end
10098
11528
 
10099
11529
  # Represents a write to a multi-target expression.
@@ -10209,6 +11639,16 @@ module Prism
10209
11639
  def type
10210
11640
  :multi_write_node
10211
11641
  end
11642
+
11643
+ # Similar to #type, this method returns a symbol that you can use for
11644
+ # splitting on the type of the node without having to do a long === chain.
11645
+ # Note that like #type, it will still be slower than using == for a single
11646
+ # class, but should be faster in a case statement or an array comparison.
11647
+ #
11648
+ # def self.type: () -> Symbol
11649
+ def self.type
11650
+ :multi_write_node
11651
+ end
10212
11652
  end
10213
11653
 
10214
11654
  # Represents the use of the `next` keyword.
@@ -10302,6 +11742,16 @@ module Prism
10302
11742
  def type
10303
11743
  :next_node
10304
11744
  end
11745
+
11746
+ # Similar to #type, this method returns a symbol that you can use for
11747
+ # splitting on the type of the node without having to do a long === chain.
11748
+ # Note that like #type, it will still be slower than using == for a single
11749
+ # class, but should be faster in a case statement or an array comparison.
11750
+ #
11751
+ # def self.type: () -> Symbol
11752
+ def self.type
11753
+ :next_node
11754
+ end
10305
11755
  end
10306
11756
 
10307
11757
  # Represents the use of the `nil` keyword.
@@ -10371,6 +11821,16 @@ module Prism
10371
11821
  def type
10372
11822
  :nil_node
10373
11823
  end
11824
+
11825
+ # Similar to #type, this method returns a symbol that you can use for
11826
+ # splitting on the type of the node without having to do a long === chain.
11827
+ # Note that like #type, it will still be slower than using == for a single
11828
+ # class, but should be faster in a case statement or an array comparison.
11829
+ #
11830
+ # def self.type: () -> Symbol
11831
+ def self.type
11832
+ :nil_node
11833
+ end
10374
11834
  end
10375
11835
 
10376
11836
  # Represents the use of `**nil` inside method arguments.
@@ -10463,6 +11923,16 @@ module Prism
10463
11923
  def type
10464
11924
  :no_keywords_parameter_node
10465
11925
  end
11926
+
11927
+ # Similar to #type, this method returns a symbol that you can use for
11928
+ # splitting on the type of the node without having to do a long === chain.
11929
+ # Note that like #type, it will still be slower than using == for a single
11930
+ # class, but should be faster in a case statement or an array comparison.
11931
+ #
11932
+ # def self.type: () -> Symbol
11933
+ def self.type
11934
+ :no_keywords_parameter_node
11935
+ end
10466
11936
  end
10467
11937
 
10468
11938
  # Represents reading a numbered reference to a capture in the previous match.
@@ -10538,6 +12008,16 @@ module Prism
10538
12008
  def type
10539
12009
  :numbered_reference_read_node
10540
12010
  end
12011
+
12012
+ # Similar to #type, this method returns a symbol that you can use for
12013
+ # splitting on the type of the node without having to do a long === chain.
12014
+ # Note that like #type, it will still be slower than using == for a single
12015
+ # class, but should be faster in a case statement or an array comparison.
12016
+ #
12017
+ # def self.type: () -> Symbol
12018
+ def self.type
12019
+ :numbered_reference_read_node
12020
+ end
10541
12021
  end
10542
12022
 
10543
12023
  # Represents an optional parameter to a method, block, or lambda definition.
@@ -10638,6 +12118,16 @@ module Prism
10638
12118
  def type
10639
12119
  :optional_parameter_node
10640
12120
  end
12121
+
12122
+ # Similar to #type, this method returns a symbol that you can use for
12123
+ # splitting on the type of the node without having to do a long === chain.
12124
+ # Note that like #type, it will still be slower than using == for a single
12125
+ # class, but should be faster in a case statement or an array comparison.
12126
+ #
12127
+ # def self.type: () -> Symbol
12128
+ def self.type
12129
+ :optional_parameter_node
12130
+ end
10641
12131
  end
10642
12132
 
10643
12133
  # Represents the use of the `||` operator or the `or` keyword.
@@ -10732,6 +12222,16 @@ module Prism
10732
12222
  def type
10733
12223
  :or_node
10734
12224
  end
12225
+
12226
+ # Similar to #type, this method returns a symbol that you can use for
12227
+ # splitting on the type of the node without having to do a long === chain.
12228
+ # Note that like #type, it will still be slower than using == for a single
12229
+ # class, but should be faster in a case statement or an array comparison.
12230
+ #
12231
+ # def self.type: () -> Symbol
12232
+ def self.type
12233
+ :or_node
12234
+ end
10735
12235
  end
10736
12236
 
10737
12237
  # Represents the list of parameters on a method, block, or lambda definition.
@@ -10867,6 +12367,16 @@ module Prism
10867
12367
  def type
10868
12368
  :parameters_node
10869
12369
  end
12370
+
12371
+ # Similar to #type, this method returns a symbol that you can use for
12372
+ # splitting on the type of the node without having to do a long === chain.
12373
+ # Note that like #type, it will still be slower than using == for a single
12374
+ # class, but should be faster in a case statement or an array comparison.
12375
+ #
12376
+ # def self.type: () -> Symbol
12377
+ def self.type
12378
+ :parameters_node
12379
+ end
10870
12380
  end
10871
12381
 
10872
12382
  # Represents a parenthesized expression
@@ -10975,6 +12485,16 @@ module Prism
10975
12485
  def type
10976
12486
  :parentheses_node
10977
12487
  end
12488
+
12489
+ # Similar to #type, this method returns a symbol that you can use for
12490
+ # splitting on the type of the node without having to do a long === chain.
12491
+ # Note that like #type, it will still be slower than using == for a single
12492
+ # class, but should be faster in a case statement or an array comparison.
12493
+ #
12494
+ # def self.type: () -> Symbol
12495
+ def self.type
12496
+ :parentheses_node
12497
+ end
10978
12498
  end
10979
12499
 
10980
12500
  # Represents the use of the `^` operator for pinning an expression in a
@@ -11085,6 +12605,16 @@ module Prism
11085
12605
  def type
11086
12606
  :pinned_expression_node
11087
12607
  end
12608
+
12609
+ # Similar to #type, this method returns a symbol that you can use for
12610
+ # splitting on the type of the node without having to do a long === chain.
12611
+ # Note that like #type, it will still be slower than using == for a single
12612
+ # class, but should be faster in a case statement or an array comparison.
12613
+ #
12614
+ # def self.type: () -> Symbol
12615
+ def self.type
12616
+ :pinned_expression_node
12617
+ end
11088
12618
  end
11089
12619
 
11090
12620
  # Represents the use of the `^` operator for pinning a variable in a pattern
@@ -11173,6 +12703,16 @@ module Prism
11173
12703
  def type
11174
12704
  :pinned_variable_node
11175
12705
  end
12706
+
12707
+ # Similar to #type, this method returns a symbol that you can use for
12708
+ # splitting on the type of the node without having to do a long === chain.
12709
+ # Note that like #type, it will still be slower than using == for a single
12710
+ # class, but should be faster in a case statement or an array comparison.
12711
+ #
12712
+ # def self.type: () -> Symbol
12713
+ def self.type
12714
+ :pinned_variable_node
12715
+ end
11176
12716
  end
11177
12717
 
11178
12718
  # Represents the use of the `END` keyword.
@@ -11288,6 +12828,16 @@ module Prism
11288
12828
  def type
11289
12829
  :post_execution_node
11290
12830
  end
12831
+
12832
+ # Similar to #type, this method returns a symbol that you can use for
12833
+ # splitting on the type of the node without having to do a long === chain.
12834
+ # Note that like #type, it will still be slower than using == for a single
12835
+ # class, but should be faster in a case statement or an array comparison.
12836
+ #
12837
+ # def self.type: () -> Symbol
12838
+ def self.type
12839
+ :post_execution_node
12840
+ end
11291
12841
  end
11292
12842
 
11293
12843
  # Represents the use of the `BEGIN` keyword.
@@ -11403,6 +12953,16 @@ module Prism
11403
12953
  def type
11404
12954
  :pre_execution_node
11405
12955
  end
12956
+
12957
+ # Similar to #type, this method returns a symbol that you can use for
12958
+ # splitting on the type of the node without having to do a long === chain.
12959
+ # Note that like #type, it will still be slower than using == for a single
12960
+ # class, but should be faster in a case statement or an array comparison.
12961
+ #
12962
+ # def self.type: () -> Symbol
12963
+ def self.type
12964
+ :pre_execution_node
12965
+ end
11406
12966
  end
11407
12967
 
11408
12968
  # The top level node of any parse tree.
@@ -11482,6 +13042,16 @@ module Prism
11482
13042
  def type
11483
13043
  :program_node
11484
13044
  end
13045
+
13046
+ # Similar to #type, this method returns a symbol that you can use for
13047
+ # splitting on the type of the node without having to do a long === chain.
13048
+ # Note that like #type, it will still be slower than using == for a single
13049
+ # class, but should be faster in a case statement or an array comparison.
13050
+ #
13051
+ # def self.type: () -> Symbol
13052
+ def self.type
13053
+ :program_node
13054
+ end
11485
13055
  end
11486
13056
 
11487
13057
  # Represents the use of the `..` or `...` operators.
@@ -11602,6 +13172,16 @@ module Prism
11602
13172
  def type
11603
13173
  :range_node
11604
13174
  end
13175
+
13176
+ # Similar to #type, this method returns a symbol that you can use for
13177
+ # splitting on the type of the node without having to do a long === chain.
13178
+ # Note that like #type, it will still be slower than using == for a single
13179
+ # class, but should be faster in a case statement or an array comparison.
13180
+ #
13181
+ # def self.type: () -> Symbol
13182
+ def self.type
13183
+ :range_node
13184
+ end
11605
13185
  end
11606
13186
 
11607
13187
  # Represents a rational number literal.
@@ -11678,6 +13258,16 @@ module Prism
11678
13258
  def type
11679
13259
  :rational_node
11680
13260
  end
13261
+
13262
+ # Similar to #type, this method returns a symbol that you can use for
13263
+ # splitting on the type of the node without having to do a long === chain.
13264
+ # Note that like #type, it will still be slower than using == for a single
13265
+ # class, but should be faster in a case statement or an array comparison.
13266
+ #
13267
+ # def self.type: () -> Symbol
13268
+ def self.type
13269
+ :rational_node
13270
+ end
11681
13271
  end
11682
13272
 
11683
13273
  # Represents the use of the `redo` keyword.
@@ -11747,6 +13337,16 @@ module Prism
11747
13337
  def type
11748
13338
  :redo_node
11749
13339
  end
13340
+
13341
+ # Similar to #type, this method returns a symbol that you can use for
13342
+ # splitting on the type of the node without having to do a long === chain.
13343
+ # Note that like #type, it will still be slower than using == for a single
13344
+ # class, but should be faster in a case statement or an array comparison.
13345
+ #
13346
+ # def self.type: () -> Symbol
13347
+ def self.type
13348
+ :redo_node
13349
+ end
11750
13350
  end
11751
13351
 
11752
13352
  # Represents a regular expression literal with no interpolation.
@@ -11849,6 +13449,11 @@ module Prism
11849
13449
  flags.anybits?(RegularExpressionFlags::MULTI_LINE)
11850
13450
  end
11851
13451
 
13452
+ # def once?: () -> bool
13453
+ def once?
13454
+ flags.anybits?(RegularExpressionFlags::ONCE)
13455
+ end
13456
+
11852
13457
  # def euc_jp?: () -> bool
11853
13458
  def euc_jp?
11854
13459
  flags.anybits?(RegularExpressionFlags::EUC_JP)
@@ -11869,18 +13474,13 @@ module Prism
11869
13474
  flags.anybits?(RegularExpressionFlags::UTF_8)
11870
13475
  end
11871
13476
 
11872
- # def once?: () -> bool
11873
- def once?
11874
- flags.anybits?(RegularExpressionFlags::ONCE)
11875
- end
11876
-
11877
13477
  def inspect(inspector = NodeInspector.new)
11878
13478
  inspector << inspector.header(self)
11879
13479
  inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
11880
13480
  inspector << "├── content_loc: #{inspector.location(content_loc)}\n"
11881
13481
  inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
11882
13482
  inspector << "├── unescaped: #{unescaped.inspect}\n"
11883
- flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?), ("once" if once?)].compact
13483
+ flags = [("ignore_case" if ignore_case?), ("extended" if extended?), ("multi_line" if multi_line?), ("once" if once?), ("euc_jp" if euc_jp?), ("ascii_8bit" if ascii_8bit?), ("windows_31j" if windows_31j?), ("utf_8" if utf_8?)].compact
11884
13484
  inspector << "└── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
11885
13485
  inspector.to_str
11886
13486
  end
@@ -11902,6 +13502,16 @@ module Prism
11902
13502
  def type
11903
13503
  :regular_expression_node
11904
13504
  end
13505
+
13506
+ # Similar to #type, this method returns a symbol that you can use for
13507
+ # splitting on the type of the node without having to do a long === chain.
13508
+ # Note that like #type, it will still be slower than using == for a single
13509
+ # class, but should be faster in a case statement or an array comparison.
13510
+ #
13511
+ # def self.type: () -> Symbol
13512
+ def self.type
13513
+ :regular_expression_node
13514
+ end
11905
13515
  end
11906
13516
 
11907
13517
  # Represents a destructured required parameter node.
@@ -12000,6 +13610,16 @@ module Prism
12000
13610
  def type
12001
13611
  :required_destructured_parameter_node
12002
13612
  end
13613
+
13614
+ # Similar to #type, this method returns a symbol that you can use for
13615
+ # splitting on the type of the node without having to do a long === chain.
13616
+ # Note that like #type, it will still be slower than using == for a single
13617
+ # class, but should be faster in a case statement or an array comparison.
13618
+ #
13619
+ # def self.type: () -> Symbol
13620
+ def self.type
13621
+ :required_destructured_parameter_node
13622
+ end
12003
13623
  end
12004
13624
 
12005
13625
  # Represents a required parameter to a method, block, or lambda definition.
@@ -12076,6 +13696,16 @@ module Prism
12076
13696
  def type
12077
13697
  :required_parameter_node
12078
13698
  end
13699
+
13700
+ # Similar to #type, this method returns a symbol that you can use for
13701
+ # splitting on the type of the node without having to do a long === chain.
13702
+ # Note that like #type, it will still be slower than using == for a single
13703
+ # class, but should be faster in a case statement or an array comparison.
13704
+ #
13705
+ # def self.type: () -> Symbol
13706
+ def self.type
13707
+ :required_parameter_node
13708
+ end
12079
13709
  end
12080
13710
 
12081
13711
  # Represents an expression modified with a rescue.
@@ -12174,6 +13804,16 @@ module Prism
12174
13804
  def type
12175
13805
  :rescue_modifier_node
12176
13806
  end
13807
+
13808
+ # Similar to #type, this method returns a symbol that you can use for
13809
+ # splitting on the type of the node without having to do a long === chain.
13810
+ # Note that like #type, it will still be slower than using == for a single
13811
+ # class, but should be faster in a case statement or an array comparison.
13812
+ #
13813
+ # def self.type: () -> Symbol
13814
+ def self.type
13815
+ :rescue_modifier_node
13816
+ end
12177
13817
  end
12178
13818
 
12179
13819
  # Represents a rescue statement.
@@ -12315,6 +13955,16 @@ module Prism
12315
13955
  def type
12316
13956
  :rescue_node
12317
13957
  end
13958
+
13959
+ # Similar to #type, this method returns a symbol that you can use for
13960
+ # splitting on the type of the node without having to do a long === chain.
13961
+ # Note that like #type, it will still be slower than using == for a single
13962
+ # class, but should be faster in a case statement or an array comparison.
13963
+ #
13964
+ # def self.type: () -> Symbol
13965
+ def self.type
13966
+ :rescue_node
13967
+ end
12318
13968
  end
12319
13969
 
12320
13970
  # Represents a rest parameter to a method, block, or lambda definition.
@@ -12408,6 +14058,16 @@ module Prism
12408
14058
  def type
12409
14059
  :rest_parameter_node
12410
14060
  end
14061
+
14062
+ # Similar to #type, this method returns a symbol that you can use for
14063
+ # splitting on the type of the node without having to do a long === chain.
14064
+ # Note that like #type, it will still be slower than using == for a single
14065
+ # class, but should be faster in a case statement or an array comparison.
14066
+ #
14067
+ # def self.type: () -> Symbol
14068
+ def self.type
14069
+ :rest_parameter_node
14070
+ end
12411
14071
  end
12412
14072
 
12413
14073
  # Represents the use of the `retry` keyword.
@@ -12477,6 +14137,16 @@ module Prism
12477
14137
  def type
12478
14138
  :retry_node
12479
14139
  end
14140
+
14141
+ # Similar to #type, this method returns a symbol that you can use for
14142
+ # splitting on the type of the node without having to do a long === chain.
14143
+ # Note that like #type, it will still be slower than using == for a single
14144
+ # class, but should be faster in a case statement or an array comparison.
14145
+ #
14146
+ # def self.type: () -> Symbol
14147
+ def self.type
14148
+ :retry_node
14149
+ end
12480
14150
  end
12481
14151
 
12482
14152
  # Represents the use of the `return` keyword.
@@ -12570,6 +14240,16 @@ module Prism
12570
14240
  def type
12571
14241
  :return_node
12572
14242
  end
14243
+
14244
+ # Similar to #type, this method returns a symbol that you can use for
14245
+ # splitting on the type of the node without having to do a long === chain.
14246
+ # Note that like #type, it will still be slower than using == for a single
14247
+ # class, but should be faster in a case statement or an array comparison.
14248
+ #
14249
+ # def self.type: () -> Symbol
14250
+ def self.type
14251
+ :return_node
14252
+ end
12573
14253
  end
12574
14254
 
12575
14255
  # Represents the `self` keyword.
@@ -12639,6 +14319,16 @@ module Prism
12639
14319
  def type
12640
14320
  :self_node
12641
14321
  end
14322
+
14323
+ # Similar to #type, this method returns a symbol that you can use for
14324
+ # splitting on the type of the node without having to do a long === chain.
14325
+ # Note that like #type, it will still be slower than using == for a single
14326
+ # class, but should be faster in a case statement or an array comparison.
14327
+ #
14328
+ # def self.type: () -> Symbol
14329
+ def self.type
14330
+ :self_node
14331
+ end
12642
14332
  end
12643
14333
 
12644
14334
  # Represents a singleton class declaration involving the `class` keyword.
@@ -12768,6 +14458,16 @@ module Prism
12768
14458
  def type
12769
14459
  :singleton_class_node
12770
14460
  end
14461
+
14462
+ # Similar to #type, this method returns a symbol that you can use for
14463
+ # splitting on the type of the node without having to do a long === chain.
14464
+ # Note that like #type, it will still be slower than using == for a single
14465
+ # class, but should be faster in a case statement or an array comparison.
14466
+ #
14467
+ # def self.type: () -> Symbol
14468
+ def self.type
14469
+ :singleton_class_node
14470
+ end
12771
14471
  end
12772
14472
 
12773
14473
  # Represents the use of the `__ENCODING__` keyword.
@@ -12837,6 +14537,16 @@ module Prism
12837
14537
  def type
12838
14538
  :source_encoding_node
12839
14539
  end
14540
+
14541
+ # Similar to #type, this method returns a symbol that you can use for
14542
+ # splitting on the type of the node without having to do a long === chain.
14543
+ # Note that like #type, it will still be slower than using == for a single
14544
+ # class, but should be faster in a case statement or an array comparison.
14545
+ #
14546
+ # def self.type: () -> Symbol
14547
+ def self.type
14548
+ :source_encoding_node
14549
+ end
12840
14550
  end
12841
14551
 
12842
14552
  # Represents the use of the `__FILE__` keyword.
@@ -12912,6 +14622,16 @@ module Prism
12912
14622
  def type
12913
14623
  :source_file_node
12914
14624
  end
14625
+
14626
+ # Similar to #type, this method returns a symbol that you can use for
14627
+ # splitting on the type of the node without having to do a long === chain.
14628
+ # Note that like #type, it will still be slower than using == for a single
14629
+ # class, but should be faster in a case statement or an array comparison.
14630
+ #
14631
+ # def self.type: () -> Symbol
14632
+ def self.type
14633
+ :source_file_node
14634
+ end
12915
14635
  end
12916
14636
 
12917
14637
  # Represents the use of the `__LINE__` keyword.
@@ -12981,6 +14701,16 @@ module Prism
12981
14701
  def type
12982
14702
  :source_line_node
12983
14703
  end
14704
+
14705
+ # Similar to #type, this method returns a symbol that you can use for
14706
+ # splitting on the type of the node without having to do a long === chain.
14707
+ # Note that like #type, it will still be slower than using == for a single
14708
+ # class, but should be faster in a case statement or an array comparison.
14709
+ #
14710
+ # def self.type: () -> Symbol
14711
+ def self.type
14712
+ :source_line_node
14713
+ end
12984
14714
  end
12985
14715
 
12986
14716
  # Represents the use of the splat operator.
@@ -13074,6 +14804,16 @@ module Prism
13074
14804
  def type
13075
14805
  :splat_node
13076
14806
  end
14807
+
14808
+ # Similar to #type, this method returns a symbol that you can use for
14809
+ # splitting on the type of the node without having to do a long === chain.
14810
+ # Note that like #type, it will still be slower than using == for a single
14811
+ # class, but should be faster in a case statement or an array comparison.
14812
+ #
14813
+ # def self.type: () -> Symbol
14814
+ def self.type
14815
+ :splat_node
14816
+ end
13077
14817
  end
13078
14818
 
13079
14819
  # Represents a set of statements contained within some scope.
@@ -13149,6 +14889,16 @@ module Prism
13149
14889
  def type
13150
14890
  :statements_node
13151
14891
  end
14892
+
14893
+ # Similar to #type, this method returns a symbol that you can use for
14894
+ # splitting on the type of the node without having to do a long === chain.
14895
+ # Note that like #type, it will still be slower than using == for a single
14896
+ # class, but should be faster in a case statement or an array comparison.
14897
+ #
14898
+ # def self.type: () -> Symbol
14899
+ def self.type
14900
+ :statements_node
14901
+ end
13152
14902
  end
13153
14903
 
13154
14904
  # Represents the use of compile-time string concatenation.
@@ -13232,6 +14982,16 @@ module Prism
13232
14982
  def type
13233
14983
  :string_concat_node
13234
14984
  end
14985
+
14986
+ # Similar to #type, this method returns a symbol that you can use for
14987
+ # splitting on the type of the node without having to do a long === chain.
14988
+ # Note that like #type, it will still be slower than using == for a single
14989
+ # class, but should be faster in a case statement or an array comparison.
14990
+ #
14991
+ # def self.type: () -> Symbol
14992
+ def self.type
14993
+ :string_concat_node
14994
+ end
13235
14995
  end
13236
14996
 
13237
14997
  # Represents a string literal, a string contained within a `%w` list, or
@@ -13359,6 +15119,16 @@ module Prism
13359
15119
  def type
13360
15120
  :string_node
13361
15121
  end
15122
+
15123
+ # Similar to #type, this method returns a symbol that you can use for
15124
+ # splitting on the type of the node without having to do a long === chain.
15125
+ # Note that like #type, it will still be slower than using == for a single
15126
+ # class, but should be faster in a case statement or an array comparison.
15127
+ #
15128
+ # def self.type: () -> Symbol
15129
+ def self.type
15130
+ :string_node
15131
+ end
13362
15132
  end
13363
15133
 
13364
15134
  # Represents the use of the `super` keyword with parentheses or arguments.
@@ -13489,6 +15259,16 @@ module Prism
13489
15259
  def type
13490
15260
  :super_node
13491
15261
  end
15262
+
15263
+ # Similar to #type, this method returns a symbol that you can use for
15264
+ # splitting on the type of the node without having to do a long === chain.
15265
+ # Note that like #type, it will still be slower than using == for a single
15266
+ # class, but should be faster in a case statement or an array comparison.
15267
+ #
15268
+ # def self.type: () -> Symbol
15269
+ def self.type
15270
+ :super_node
15271
+ end
13492
15272
  end
13493
15273
 
13494
15274
  # Represents a symbol literal or a symbol contained within a `%i` list.
@@ -13600,6 +15380,16 @@ module Prism
13600
15380
  def type
13601
15381
  :symbol_node
13602
15382
  end
15383
+
15384
+ # Similar to #type, this method returns a symbol that you can use for
15385
+ # splitting on the type of the node without having to do a long === chain.
15386
+ # Note that like #type, it will still be slower than using == for a single
15387
+ # class, but should be faster in a case statement or an array comparison.
15388
+ #
15389
+ # def self.type: () -> Symbol
15390
+ def self.type
15391
+ :symbol_node
15392
+ end
13603
15393
  end
13604
15394
 
13605
15395
  # Represents the use of the literal `true` keyword.
@@ -13669,6 +15459,16 @@ module Prism
13669
15459
  def type
13670
15460
  :true_node
13671
15461
  end
15462
+
15463
+ # Similar to #type, this method returns a symbol that you can use for
15464
+ # splitting on the type of the node without having to do a long === chain.
15465
+ # Note that like #type, it will still be slower than using == for a single
15466
+ # class, but should be faster in a case statement or an array comparison.
15467
+ #
15468
+ # def self.type: () -> Symbol
15469
+ def self.type
15470
+ :true_node
15471
+ end
13672
15472
  end
13673
15473
 
13674
15474
  # Represents the use of the `undef` keyword.
@@ -13755,6 +15555,16 @@ module Prism
13755
15555
  def type
13756
15556
  :undef_node
13757
15557
  end
15558
+
15559
+ # Similar to #type, this method returns a symbol that you can use for
15560
+ # splitting on the type of the node without having to do a long === chain.
15561
+ # Note that like #type, it will still be slower than using == for a single
15562
+ # class, but should be faster in a case statement or an array comparison.
15563
+ #
15564
+ # def self.type: () -> Symbol
15565
+ def self.type
15566
+ :undef_node
15567
+ end
13758
15568
  end
13759
15569
 
13760
15570
  # Represents the use of the `unless` keyword, either in the block form or the modifier form.
@@ -13886,6 +15696,16 @@ module Prism
13886
15696
  def type
13887
15697
  :unless_node
13888
15698
  end
15699
+
15700
+ # Similar to #type, this method returns a symbol that you can use for
15701
+ # splitting on the type of the node without having to do a long === chain.
15702
+ # Note that like #type, it will still be slower than using == for a single
15703
+ # class, but should be faster in a case statement or an array comparison.
15704
+ #
15705
+ # def self.type: () -> Symbol
15706
+ def self.type
15707
+ :unless_node
15708
+ end
13889
15709
  end
13890
15710
 
13891
15711
  # Represents the use of the `until` keyword, either in the block form or the modifier form.
@@ -14017,6 +15837,16 @@ module Prism
14017
15837
  def type
14018
15838
  :until_node
14019
15839
  end
15840
+
15841
+ # Similar to #type, this method returns a symbol that you can use for
15842
+ # splitting on the type of the node without having to do a long === chain.
15843
+ # Note that like #type, it will still be slower than using == for a single
15844
+ # class, but should be faster in a case statement or an array comparison.
15845
+ #
15846
+ # def self.type: () -> Symbol
15847
+ def self.type
15848
+ :until_node
15849
+ end
14020
15850
  end
14021
15851
 
14022
15852
  # Represents the use of the `when` keyword within a case statement.
@@ -14119,6 +15949,16 @@ module Prism
14119
15949
  def type
14120
15950
  :when_node
14121
15951
  end
15952
+
15953
+ # Similar to #type, this method returns a symbol that you can use for
15954
+ # splitting on the type of the node without having to do a long === chain.
15955
+ # Note that like #type, it will still be slower than using == for a single
15956
+ # class, but should be faster in a case statement or an array comparison.
15957
+ #
15958
+ # def self.type: () -> Symbol
15959
+ def self.type
15960
+ :when_node
15961
+ end
14122
15962
  end
14123
15963
 
14124
15964
  # Represents the use of the `while` keyword, either in the block form or the modifier form.
@@ -14250,6 +16090,16 @@ module Prism
14250
16090
  def type
14251
16091
  :while_node
14252
16092
  end
16093
+
16094
+ # Similar to #type, this method returns a symbol that you can use for
16095
+ # splitting on the type of the node without having to do a long === chain.
16096
+ # Note that like #type, it will still be slower than using == for a single
16097
+ # class, but should be faster in a case statement or an array comparison.
16098
+ #
16099
+ # def self.type: () -> Symbol
16100
+ def self.type
16101
+ :while_node
16102
+ end
14253
16103
  end
14254
16104
 
14255
16105
  # Represents an xstring literal with no interpolation.
@@ -14358,6 +16208,16 @@ module Prism
14358
16208
  def type
14359
16209
  :x_string_node
14360
16210
  end
16211
+
16212
+ # Similar to #type, this method returns a symbol that you can use for
16213
+ # splitting on the type of the node without having to do a long === chain.
16214
+ # Note that like #type, it will still be slower than using == for a single
16215
+ # class, but should be faster in a case statement or an array comparison.
16216
+ #
16217
+ # def self.type: () -> Symbol
16218
+ def self.type
16219
+ :x_string_node
16220
+ end
14361
16221
  end
14362
16222
 
14363
16223
  # Represents the use of the `yield` keyword.
@@ -14473,6 +16333,16 @@ module Prism
14473
16333
  def type
14474
16334
  :yield_node
14475
16335
  end
16336
+
16337
+ # Similar to #type, this method returns a symbol that you can use for
16338
+ # splitting on the type of the node without having to do a long === chain.
16339
+ # Note that like #type, it will still be slower than using == for a single
16340
+ # class, but should be faster in a case statement or an array comparison.
16341
+ #
16342
+ # def self.type: () -> Symbol
16343
+ def self.type
16344
+ :yield_node
16345
+ end
14476
16346
  end
14477
16347
 
14478
16348
  module CallNodeFlags
@@ -14517,24 +16387,24 @@ module Prism
14517
16387
  # m - allows $ to match the end of lines within strings
14518
16388
  MULTI_LINE = 1 << 2
14519
16389
 
16390
+ # o - only interpolates values into the regular expression once
16391
+ ONCE = 1 << 3
16392
+
14520
16393
  # e - forces the EUC-JP encoding
14521
- EUC_JP = 1 << 3
16394
+ EUC_JP = 1 << 4
14522
16395
 
14523
16396
  # n - forces the ASCII-8BIT encoding
14524
- ASCII_8BIT = 1 << 4
16397
+ ASCII_8BIT = 1 << 5
14525
16398
 
14526
16399
  # s - forces the Windows-31J encoding
14527
- WINDOWS_31J = 1 << 5
16400
+ WINDOWS_31J = 1 << 6
14528
16401
 
14529
16402
  # u - forces the UTF-8 encoding
14530
- UTF_8 = 1 << 6
14531
-
14532
- # o - only interpolates values into the regular expression once
14533
- ONCE = 1 << 7
16403
+ UTF_8 = 1 << 7
14534
16404
  end
14535
16405
 
14536
16406
  module StringFlags
14537
- # frozen by virtue of a frozen_string_literal comment
16407
+ # frozen by virtue of a `frozen_string_literal` comment
14538
16408
  FROZEN = 1 << 0
14539
16409
  end
14540
16410
  end