prism 1.0.0 → 1.1.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
@@ -370,10 +370,28 @@ module Prism
370
370
  { node_id: node_id, location: location, new_name: new_name, old_name: old_name, keyword_loc: keyword_loc }
371
371
  end
372
372
 
373
- # attr_reader new_name: SymbolNode | InterpolatedSymbolNode
373
+ # Represents the new name of the method that will be aliased.
374
+ #
375
+ # alias foo bar
376
+ # ^^^
377
+ #
378
+ # alias :foo :bar
379
+ # ^^^^
380
+ #
381
+ # alias :"#{foo}" :"#{bar}"
382
+ # ^^^^^^^^^
374
383
  attr_reader :new_name
375
384
 
376
- # attr_reader old_name: SymbolNode | InterpolatedSymbolNode | GlobalVariableReadNode | MissingNode
385
+ # Represents the old name of the method that will be aliased.
386
+ #
387
+ # alias foo bar
388
+ # ^^^
389
+ #
390
+ # alias :foo :bar
391
+ # ^^^^
392
+ #
393
+ # alias :"#{foo}" :"#{bar}"
394
+ # ^^^^^^^^^
377
395
  attr_reader :old_name
378
396
 
379
397
  # attr_reader keyword_loc: Location
@@ -462,13 +480,22 @@ module Prism
462
480
  { node_id: node_id, location: location, left: left, right: right, operator_loc: operator_loc }
463
481
  end
464
482
 
465
- # attr_reader left: Prism::node
483
+ # Represents the left side of the expression.
484
+ #
485
+ # foo => bar | baz
486
+ # ^^^
466
487
  attr_reader :left
467
488
 
468
- # attr_reader right: Prism::node
489
+ # Represents the right side of the expression.
490
+ #
491
+ # foo => bar | baz
492
+ # ^^^
469
493
  attr_reader :right
470
494
 
471
- # attr_reader operator_loc: Location
495
+ # Represents the alternation operator location.
496
+ #
497
+ # foo => bar | baz
498
+ # ^
472
499
  def operator_loc
473
500
  location = @operator_loc
474
501
  return location if location.is_a?(Location)
@@ -563,7 +590,7 @@ module Prism
563
590
  # ^
564
591
  attr_reader :left
565
592
 
566
- # Represents the right side of the expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
593
+ # Represents the right side of the expression.
567
594
  #
568
595
  # left && right
569
596
  # ^^^^^
@@ -659,6 +686,11 @@ module Prism
659
686
  { node_id: node_id, location: location, arguments: arguments }
660
687
  end
661
688
 
689
+ # def contains_forwarding?: () -> bool
690
+ def contains_forwarding?
691
+ flags.anybits?(ArgumentsNodeFlags::CONTAINS_FORWARDING)
692
+ end
693
+
662
694
  # def contains_keywords?: () -> bool
663
695
  def contains_keywords?
664
696
  flags.anybits?(ArgumentsNodeFlags::CONTAINS_KEYWORDS)
@@ -674,6 +706,11 @@ module Prism
674
706
  flags.anybits?(ArgumentsNodeFlags::CONTAINS_SPLAT)
675
707
  end
676
708
 
709
+ # def contains_multiple_splats?: () -> bool
710
+ def contains_multiple_splats?
711
+ flags.anybits?(ArgumentsNodeFlags::CONTAINS_MULTIPLE_SPLATS)
712
+ end
713
+
677
714
  # attr_reader arguments: Array[Prism::node]
678
715
  attr_reader :arguments
679
716
 
@@ -888,7 +925,7 @@ module Prism
888
925
  [*constant, *requireds, *rest, *posts, *opening_loc, *closing_loc] #: Array[Prism::node | Location]
889
926
  end
890
927
 
891
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: Prism::node?, ?requireds: Array[Prism::node], ?rest: Prism::node?, ?posts: Array[Prism::node], ?opening_loc: Location?, ?closing_loc: Location?) -> ArrayPatternNode
928
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantReadNode | ConstantPathNode | nil, ?requireds: Array[Prism::node], ?rest: Prism::node?, ?posts: Array[Prism::node], ?opening_loc: Location?, ?closing_loc: Location?) -> ArrayPatternNode
892
929
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, constant: self.constant, requireds: self.requireds, rest: self.rest, posts: self.posts, opening_loc: self.opening_loc, closing_loc: self.closing_loc)
893
930
  ArrayPatternNode.new(source, node_id, location, flags, constant, requireds, rest, posts, opening_loc, closing_loc)
894
931
  end
@@ -896,12 +933,12 @@ module Prism
896
933
  # def deconstruct: () -> Array[nil | Node]
897
934
  alias deconstruct child_nodes
898
935
 
899
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: Prism::node?, requireds: Array[Prism::node], rest: Prism::node?, posts: Array[Prism::node], opening_loc: Location?, closing_loc: Location? }
936
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantReadNode | ConstantPathNode | nil, requireds: Array[Prism::node], rest: Prism::node?, posts: Array[Prism::node], opening_loc: Location?, closing_loc: Location? }
900
937
  def deconstruct_keys(keys)
901
938
  { node_id: node_id, location: location, constant: constant, requireds: requireds, rest: rest, posts: posts, opening_loc: opening_loc, closing_loc: closing_loc }
902
939
  end
903
940
 
904
- # attr_reader constant: Prism::node?
941
+ # attr_reader constant: ConstantReadNode | ConstantPathNode | nil
905
942
  attr_reader :constant
906
943
 
907
944
  # attr_reader requireds: Array[Prism::node]
@@ -2241,7 +2278,7 @@ module Prism
2241
2278
  [*receiver, *call_operator_loc, *message_loc, *opening_loc, *arguments, *closing_loc, *block] #: Array[Prism::node | Location]
2242
2279
  end
2243
2280
 
2244
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?name: Symbol, ?message_loc: Location?, ?opening_loc: Location?, ?arguments: ArgumentsNode?, ?closing_loc: Location?, ?block: Prism::node?) -> CallNode
2281
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?name: Symbol, ?message_loc: Location?, ?opening_loc: Location?, ?arguments: ArgumentsNode?, ?closing_loc: Location?, ?block: BlockNode | BlockArgumentNode | nil) -> CallNode
2245
2282
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, name: self.name, message_loc: self.message_loc, opening_loc: self.opening_loc, arguments: self.arguments, closing_loc: self.closing_loc, block: self.block)
2246
2283
  CallNode.new(source, node_id, location, flags, receiver, call_operator_loc, name, message_loc, opening_loc, arguments, closing_loc, block)
2247
2284
  end
@@ -2249,7 +2286,7 @@ module Prism
2249
2286
  # def deconstruct: () -> Array[nil | Node]
2250
2287
  alias deconstruct child_nodes
2251
2288
 
2252
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, name: Symbol, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: Prism::node? }
2289
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, name: Symbol, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, block: BlockNode | BlockArgumentNode | nil }
2253
2290
  def deconstruct_keys(keys)
2254
2291
  { node_id: node_id, location: location, receiver: receiver, call_operator_loc: call_operator_loc, name: name, message_loc: message_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block }
2255
2292
  end
@@ -2344,7 +2381,7 @@ module Prism
2344
2381
  end
2345
2382
  end
2346
2383
 
2347
- # attr_reader block: Prism::node?
2384
+ # attr_reader block: BlockNode | BlockArgumentNode | nil
2348
2385
  attr_reader :block
2349
2386
 
2350
2387
  # def call_operator: () -> String?
@@ -2901,7 +2938,7 @@ module Prism
2901
2938
  [value, target, operator_loc] #: Array[Prism::node | Location]
2902
2939
  end
2903
2940
 
2904
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?target: Prism::node, ?operator_loc: Location) -> CapturePatternNode
2941
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node, ?target: LocalVariableTargetNode, ?operator_loc: Location) -> CapturePatternNode
2905
2942
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, value: self.value, target: self.target, operator_loc: self.operator_loc)
2906
2943
  CapturePatternNode.new(source, node_id, location, flags, value, target, operator_loc)
2907
2944
  end
@@ -2909,7 +2946,7 @@ module Prism
2909
2946
  # def deconstruct: () -> Array[nil | Node]
2910
2947
  alias deconstruct child_nodes
2911
2948
 
2912
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node, target: Prism::node, operator_loc: Location }
2949
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node, target: LocalVariableTargetNode, operator_loc: Location }
2913
2950
  def deconstruct_keys(keys)
2914
2951
  { node_id: node_id, location: location, value: value, target: target, operator_loc: operator_loc }
2915
2952
  end
@@ -2917,7 +2954,7 @@ module Prism
2917
2954
  # attr_reader value: Prism::node
2918
2955
  attr_reader :value
2919
2956
 
2920
- # attr_reader target: Prism::node
2957
+ # attr_reader target: LocalVariableTargetNode
2921
2958
  attr_reader :target
2922
2959
 
2923
2960
  # attr_reader operator_loc: Location
@@ -3001,7 +3038,7 @@ module Prism
3001
3038
  [*predicate, *conditions, *else_clause, case_keyword_loc, end_keyword_loc] #: Array[Prism::node | Location]
3002
3039
  end
3003
3040
 
3004
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?predicate: Prism::node?, ?conditions: Array[Prism::node], ?else_clause: ElseNode?, ?case_keyword_loc: Location, ?end_keyword_loc: Location) -> CaseMatchNode
3041
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?predicate: Prism::node?, ?conditions: Array[InNode], ?else_clause: ElseNode?, ?case_keyword_loc: Location, ?end_keyword_loc: Location) -> CaseMatchNode
3005
3042
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, predicate: self.predicate, conditions: self.conditions, else_clause: self.else_clause, case_keyword_loc: self.case_keyword_loc, end_keyword_loc: self.end_keyword_loc)
3006
3043
  CaseMatchNode.new(source, node_id, location, flags, predicate, conditions, else_clause, case_keyword_loc, end_keyword_loc)
3007
3044
  end
@@ -3009,7 +3046,7 @@ module Prism
3009
3046
  # def deconstruct: () -> Array[nil | Node]
3010
3047
  alias deconstruct child_nodes
3011
3048
 
3012
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, predicate: Prism::node?, conditions: Array[Prism::node], else_clause: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location }
3049
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, predicate: Prism::node?, conditions: Array[InNode], else_clause: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location }
3013
3050
  def deconstruct_keys(keys)
3014
3051
  { node_id: node_id, location: location, predicate: predicate, conditions: conditions, else_clause: else_clause, case_keyword_loc: case_keyword_loc, end_keyword_loc: end_keyword_loc }
3015
3052
  end
@@ -3017,7 +3054,7 @@ module Prism
3017
3054
  # attr_reader predicate: Prism::node?
3018
3055
  attr_reader :predicate
3019
3056
 
3020
- # attr_reader conditions: Array[Prism::node]
3057
+ # attr_reader conditions: Array[InNode]
3021
3058
  attr_reader :conditions
3022
3059
 
3023
3060
  # attr_reader else_clause: ElseNode?
@@ -3119,7 +3156,7 @@ module Prism
3119
3156
  [*predicate, *conditions, *else_clause, case_keyword_loc, end_keyword_loc] #: Array[Prism::node | Location]
3120
3157
  end
3121
3158
 
3122
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?predicate: Prism::node?, ?conditions: Array[Prism::node], ?else_clause: ElseNode?, ?case_keyword_loc: Location, ?end_keyword_loc: Location) -> CaseNode
3159
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?predicate: Prism::node?, ?conditions: Array[WhenNode], ?else_clause: ElseNode?, ?case_keyword_loc: Location, ?end_keyword_loc: Location) -> CaseNode
3123
3160
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, predicate: self.predicate, conditions: self.conditions, else_clause: self.else_clause, case_keyword_loc: self.case_keyword_loc, end_keyword_loc: self.end_keyword_loc)
3124
3161
  CaseNode.new(source, node_id, location, flags, predicate, conditions, else_clause, case_keyword_loc, end_keyword_loc)
3125
3162
  end
@@ -3127,7 +3164,7 @@ module Prism
3127
3164
  # def deconstruct: () -> Array[nil | Node]
3128
3165
  alias deconstruct child_nodes
3129
3166
 
3130
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, predicate: Prism::node?, conditions: Array[Prism::node], else_clause: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location }
3167
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, predicate: Prism::node?, conditions: Array[WhenNode], else_clause: ElseNode?, case_keyword_loc: Location, end_keyword_loc: Location }
3131
3168
  def deconstruct_keys(keys)
3132
3169
  { node_id: node_id, location: location, predicate: predicate, conditions: conditions, else_clause: else_clause, case_keyword_loc: case_keyword_loc, end_keyword_loc: end_keyword_loc }
3133
3170
  end
@@ -3135,7 +3172,7 @@ module Prism
3135
3172
  # attr_reader predicate: Prism::node?
3136
3173
  attr_reader :predicate
3137
3174
 
3138
- # attr_reader conditions: Array[Prism::node]
3175
+ # attr_reader conditions: Array[WhenNode]
3139
3176
  attr_reader :conditions
3140
3177
 
3141
3178
  # attr_reader else_clause: ElseNode?
@@ -3238,7 +3275,7 @@ module Prism
3238
3275
  [class_keyword_loc, constant_path, *inheritance_operator_loc, *superclass, *body, end_keyword_loc] #: Array[Prism::node | Location]
3239
3276
  end
3240
3277
 
3241
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?class_keyword_loc: Location, ?constant_path: Prism::node, ?inheritance_operator_loc: Location?, ?superclass: Prism::node?, ?body: Prism::node?, ?end_keyword_loc: Location, ?name: Symbol) -> ClassNode
3278
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?class_keyword_loc: Location, ?constant_path: ConstantReadNode | ConstantPathNode | CallNode, ?inheritance_operator_loc: Location?, ?superclass: Prism::node?, ?body: StatementsNode | BeginNode | nil, ?end_keyword_loc: Location, ?name: Symbol) -> ClassNode
3242
3279
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, locals: self.locals, class_keyword_loc: self.class_keyword_loc, constant_path: self.constant_path, inheritance_operator_loc: self.inheritance_operator_loc, superclass: self.superclass, body: self.body, end_keyword_loc: self.end_keyword_loc, name: self.name)
3243
3280
  ClassNode.new(source, node_id, location, flags, locals, class_keyword_loc, constant_path, inheritance_operator_loc, superclass, body, end_keyword_loc, name)
3244
3281
  end
@@ -3246,7 +3283,7 @@ module Prism
3246
3283
  # def deconstruct: () -> Array[nil | Node]
3247
3284
  alias deconstruct child_nodes
3248
3285
 
3249
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], class_keyword_loc: Location, constant_path: Prism::node, inheritance_operator_loc: Location?, superclass: Prism::node?, body: Prism::node?, end_keyword_loc: Location, name: Symbol }
3286
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], class_keyword_loc: Location, constant_path: ConstantReadNode | ConstantPathNode | CallNode, inheritance_operator_loc: Location?, superclass: Prism::node?, body: StatementsNode | BeginNode | nil, end_keyword_loc: Location, name: Symbol }
3250
3287
  def deconstruct_keys(keys)
3251
3288
  { node_id: node_id, location: location, locals: locals, class_keyword_loc: class_keyword_loc, constant_path: constant_path, inheritance_operator_loc: inheritance_operator_loc, superclass: superclass, body: body, end_keyword_loc: end_keyword_loc, name: name }
3252
3289
  end
@@ -3261,7 +3298,7 @@ module Prism
3261
3298
  @class_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
3262
3299
  end
3263
3300
 
3264
- # attr_reader constant_path: Prism::node
3301
+ # attr_reader constant_path: ConstantReadNode | ConstantPathNode | CallNode
3265
3302
  attr_reader :constant_path
3266
3303
 
3267
3304
  # attr_reader inheritance_operator_loc: Location?
@@ -3280,7 +3317,7 @@ module Prism
3280
3317
  # attr_reader superclass: Prism::node?
3281
3318
  attr_reader :superclass
3282
3319
 
3283
- # attr_reader body: Prism::node?
3320
+ # attr_reader body: StatementsNode | BeginNode | nil
3284
3321
  attr_reader :body
3285
3322
 
3286
3323
  # attr_reader end_keyword_loc: Location
@@ -5142,7 +5179,7 @@ module Prism
5142
5179
  [name_loc, *receiver, *parameters, *body, def_keyword_loc, *operator_loc, *lparen_loc, *rparen_loc, *equal_loc, *end_keyword_loc] #: Array[Prism::node | Location]
5143
5180
  end
5144
5181
 
5145
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?receiver: Prism::node?, ?parameters: ParametersNode?, ?body: Prism::node?, ?locals: Array[Symbol], ?def_keyword_loc: Location, ?operator_loc: Location?, ?lparen_loc: Location?, ?rparen_loc: Location?, ?equal_loc: Location?, ?end_keyword_loc: Location?) -> DefNode
5182
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?name: Symbol, ?name_loc: Location, ?receiver: Prism::node?, ?parameters: ParametersNode?, ?body: StatementsNode | BeginNode | nil, ?locals: Array[Symbol], ?def_keyword_loc: Location, ?operator_loc: Location?, ?lparen_loc: Location?, ?rparen_loc: Location?, ?equal_loc: Location?, ?end_keyword_loc: Location?) -> DefNode
5146
5183
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, name: self.name, name_loc: self.name_loc, receiver: self.receiver, parameters: self.parameters, body: self.body, locals: self.locals, def_keyword_loc: self.def_keyword_loc, operator_loc: self.operator_loc, lparen_loc: self.lparen_loc, rparen_loc: self.rparen_loc, equal_loc: self.equal_loc, end_keyword_loc: self.end_keyword_loc)
5147
5184
  DefNode.new(source, node_id, location, flags, name, name_loc, receiver, parameters, body, locals, def_keyword_loc, operator_loc, lparen_loc, rparen_loc, equal_loc, end_keyword_loc)
5148
5185
  end
@@ -5150,7 +5187,7 @@ module Prism
5150
5187
  # def deconstruct: () -> Array[nil | Node]
5151
5188
  alias deconstruct child_nodes
5152
5189
 
5153
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, receiver: Prism::node?, parameters: ParametersNode?, body: Prism::node?, locals: Array[Symbol], def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location? }
5190
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, name: Symbol, name_loc: Location, receiver: Prism::node?, parameters: ParametersNode?, body: StatementsNode | BeginNode | nil, locals: Array[Symbol], def_keyword_loc: Location, operator_loc: Location?, lparen_loc: Location?, rparen_loc: Location?, equal_loc: Location?, end_keyword_loc: Location? }
5154
5191
  def deconstruct_keys(keys)
5155
5192
  { node_id: node_id, location: location, name: name, name_loc: name_loc, receiver: receiver, parameters: parameters, body: body, locals: locals, def_keyword_loc: def_keyword_loc, operator_loc: operator_loc, lparen_loc: lparen_loc, rparen_loc: rparen_loc, equal_loc: equal_loc, end_keyword_loc: end_keyword_loc }
5156
5193
  end
@@ -5171,7 +5208,7 @@ module Prism
5171
5208
  # attr_reader parameters: ParametersNode?
5172
5209
  attr_reader :parameters
5173
5210
 
5174
- # attr_reader body: Prism::node?
5211
+ # attr_reader body: StatementsNode | BeginNode | nil
5175
5212
  attr_reader :body
5176
5213
 
5177
5214
  # attr_reader locals: Array[Symbol]
@@ -5688,7 +5725,7 @@ module Prism
5688
5725
  [operator_loc, variable] #: Array[Prism::node | Location]
5689
5726
  end
5690
5727
 
5691
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?operator_loc: Location, ?variable: Prism::node) -> EmbeddedVariableNode
5728
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?operator_loc: Location, ?variable: InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode) -> EmbeddedVariableNode
5692
5729
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, operator_loc: self.operator_loc, variable: self.variable)
5693
5730
  EmbeddedVariableNode.new(source, node_id, location, flags, operator_loc, variable)
5694
5731
  end
@@ -5696,7 +5733,7 @@ module Prism
5696
5733
  # def deconstruct: () -> Array[nil | Node]
5697
5734
  alias deconstruct child_nodes
5698
5735
 
5699
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, operator_loc: Location, variable: Prism::node }
5736
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, operator_loc: Location, variable: InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode }
5700
5737
  def deconstruct_keys(keys)
5701
5738
  { node_id: node_id, location: location, operator_loc: operator_loc, variable: variable }
5702
5739
  end
@@ -5708,7 +5745,7 @@ module Prism
5708
5745
  @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
5709
5746
  end
5710
5747
 
5711
- # attr_reader variable: Prism::node
5748
+ # attr_reader variable: InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode
5712
5749
  attr_reader :variable
5713
5750
 
5714
5751
  # def operator: () -> String
@@ -5965,7 +6002,7 @@ module Prism
5965
6002
  [*constant, left, *requireds, right, *opening_loc, *closing_loc] #: Array[Prism::node | Location]
5966
6003
  end
5967
6004
 
5968
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: Prism::node?, ?left: Prism::node, ?requireds: Array[Prism::node], ?right: Prism::node, ?opening_loc: Location?, ?closing_loc: Location?) -> FindPatternNode
6005
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantReadNode | ConstantPathNode | nil, ?left: SplatNode, ?requireds: Array[Prism::node], ?right: SplatNode | MissingNode, ?opening_loc: Location?, ?closing_loc: Location?) -> FindPatternNode
5969
6006
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, constant: self.constant, left: self.left, requireds: self.requireds, right: self.right, opening_loc: self.opening_loc, closing_loc: self.closing_loc)
5970
6007
  FindPatternNode.new(source, node_id, location, flags, constant, left, requireds, right, opening_loc, closing_loc)
5971
6008
  end
@@ -5973,21 +6010,21 @@ module Prism
5973
6010
  # def deconstruct: () -> Array[nil | Node]
5974
6011
  alias deconstruct child_nodes
5975
6012
 
5976
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: Prism::node?, left: Prism::node, requireds: Array[Prism::node], right: Prism::node, opening_loc: Location?, closing_loc: Location? }
6013
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantReadNode | ConstantPathNode | nil, left: SplatNode, requireds: Array[Prism::node], right: SplatNode | MissingNode, opening_loc: Location?, closing_loc: Location? }
5977
6014
  def deconstruct_keys(keys)
5978
6015
  { node_id: node_id, location: location, constant: constant, left: left, requireds: requireds, right: right, opening_loc: opening_loc, closing_loc: closing_loc }
5979
6016
  end
5980
6017
 
5981
- # attr_reader constant: Prism::node?
6018
+ # attr_reader constant: ConstantReadNode | ConstantPathNode | nil
5982
6019
  attr_reader :constant
5983
6020
 
5984
- # attr_reader left: Prism::node
6021
+ # attr_reader left: SplatNode
5985
6022
  attr_reader :left
5986
6023
 
5987
6024
  # attr_reader requireds: Array[Prism::node]
5988
6025
  attr_reader :requireds
5989
6026
 
5990
- # attr_reader right: Prism::node
6027
+ # attr_reader right: SplatNode | MissingNode
5991
6028
  attr_reader :right
5992
6029
 
5993
6030
  # attr_reader opening_loc: Location?
@@ -6273,7 +6310,7 @@ module Prism
6273
6310
  [index, collection, *statements, for_keyword_loc, in_keyword_loc, *do_keyword_loc, end_keyword_loc] #: Array[Prism::node | Location]
6274
6311
  end
6275
6312
 
6276
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?index: Prism::node, ?collection: Prism::node, ?statements: StatementsNode?, ?for_keyword_loc: Location, ?in_keyword_loc: Location, ?do_keyword_loc: Location?, ?end_keyword_loc: Location) -> ForNode
6313
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?index: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode, ?collection: Prism::node, ?statements: StatementsNode?, ?for_keyword_loc: Location, ?in_keyword_loc: Location, ?do_keyword_loc: Location?, ?end_keyword_loc: Location) -> ForNode
6277
6314
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, index: self.index, collection: self.collection, statements: self.statements, for_keyword_loc: self.for_keyword_loc, in_keyword_loc: self.in_keyword_loc, do_keyword_loc: self.do_keyword_loc, end_keyword_loc: self.end_keyword_loc)
6278
6315
  ForNode.new(source, node_id, location, flags, index, collection, statements, for_keyword_loc, in_keyword_loc, do_keyword_loc, end_keyword_loc)
6279
6316
  end
@@ -6281,7 +6318,7 @@ module Prism
6281
6318
  # def deconstruct: () -> Array[nil | Node]
6282
6319
  alias deconstruct child_nodes
6283
6320
 
6284
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, index: Prism::node, collection: Prism::node, statements: StatementsNode?, for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: Location?, end_keyword_loc: Location }
6321
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, index: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode, collection: Prism::node, statements: StatementsNode?, for_keyword_loc: Location, in_keyword_loc: Location, do_keyword_loc: Location?, end_keyword_loc: Location }
6285
6322
  def deconstruct_keys(keys)
6286
6323
  { node_id: node_id, location: location, index: index, collection: collection, statements: statements, for_keyword_loc: for_keyword_loc, in_keyword_loc: in_keyword_loc, do_keyword_loc: do_keyword_loc, end_keyword_loc: end_keyword_loc }
6287
6324
  end
@@ -7344,7 +7381,7 @@ module Prism
7344
7381
  [*constant, *elements, *rest, *opening_loc, *closing_loc] #: Array[Prism::node | Location]
7345
7382
  end
7346
7383
 
7347
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: Prism::node?, ?elements: Array[AssocNode], ?rest: AssocSplatNode | NoKeywordsParameterNode | nil, ?opening_loc: Location?, ?closing_loc: Location?) -> HashPatternNode
7384
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?constant: ConstantReadNode | ConstantPathNode | nil, ?elements: Array[AssocNode], ?rest: AssocSplatNode | NoKeywordsParameterNode | nil, ?opening_loc: Location?, ?closing_loc: Location?) -> HashPatternNode
7348
7385
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, constant: self.constant, elements: self.elements, rest: self.rest, opening_loc: self.opening_loc, closing_loc: self.closing_loc)
7349
7386
  HashPatternNode.new(source, node_id, location, flags, constant, elements, rest, opening_loc, closing_loc)
7350
7387
  end
@@ -7352,12 +7389,12 @@ module Prism
7352
7389
  # def deconstruct: () -> Array[nil | Node]
7353
7390
  alias deconstruct child_nodes
7354
7391
 
7355
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: Prism::node?, elements: Array[AssocNode], rest: AssocSplatNode | NoKeywordsParameterNode | nil, opening_loc: Location?, closing_loc: Location? }
7392
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, constant: ConstantReadNode | ConstantPathNode | nil, elements: Array[AssocNode], rest: AssocSplatNode | NoKeywordsParameterNode | nil, opening_loc: Location?, closing_loc: Location? }
7356
7393
  def deconstruct_keys(keys)
7357
7394
  { node_id: node_id, location: location, constant: constant, elements: elements, rest: rest, opening_loc: opening_loc, closing_loc: closing_loc }
7358
7395
  end
7359
7396
 
7360
- # attr_reader constant: Prism::node?
7397
+ # attr_reader constant: ConstantReadNode | ConstantPathNode | nil
7361
7398
  attr_reader :constant
7362
7399
 
7363
7400
  # attr_reader elements: Array[AssocNode]
@@ -7742,7 +7779,7 @@ module Prism
7742
7779
  [value] #: Array[Prism::node | Location]
7743
7780
  end
7744
7781
 
7745
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: Prism::node) -> ImplicitNode
7782
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?value: LocalVariableReadNode | CallNode | ConstantReadNode | LocalVariableTargetNode) -> ImplicitNode
7746
7783
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, value: self.value)
7747
7784
  ImplicitNode.new(source, node_id, location, flags, value)
7748
7785
  end
@@ -7750,12 +7787,12 @@ module Prism
7750
7787
  # def deconstruct: () -> Array[nil | Node]
7751
7788
  alias deconstruct child_nodes
7752
7789
 
7753
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: Prism::node }
7790
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, value: LocalVariableReadNode | CallNode | ConstantReadNode | LocalVariableTargetNode }
7754
7791
  def deconstruct_keys(keys)
7755
7792
  { node_id: node_id, location: location, value: value }
7756
7793
  end
7757
7794
 
7758
- # attr_reader value: Prism::node
7795
+ # attr_reader value: LocalVariableReadNode | CallNode | ConstantReadNode | LocalVariableTargetNode
7759
7796
  attr_reader :value
7760
7797
 
7761
7798
  # def inspect -> String
@@ -8019,7 +8056,7 @@ module Prism
8019
8056
  [*receiver, *call_operator_loc, opening_loc, *arguments, closing_loc, *block, operator_loc, value] #: Array[Prism::node | Location]
8020
8057
  end
8021
8058
 
8022
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: Prism::node?, ?operator_loc: Location, ?value: Prism::node) -> IndexAndWriteNode
8059
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: BlockArgumentNode?, ?operator_loc: Location, ?value: Prism::node) -> IndexAndWriteNode
8023
8060
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, opening_loc: self.opening_loc, arguments: self.arguments, closing_loc: self.closing_loc, block: self.block, operator_loc: self.operator_loc, value: self.value)
8024
8061
  IndexAndWriteNode.new(source, node_id, location, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value)
8025
8062
  end
@@ -8027,7 +8064,7 @@ module Prism
8027
8064
  # def deconstruct: () -> Array[nil | Node]
8028
8065
  alias deconstruct child_nodes
8029
8066
 
8030
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Prism::node?, operator_loc: Location, value: Prism::node }
8067
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode?, operator_loc: Location, value: Prism::node }
8031
8068
  def deconstruct_keys(keys)
8032
8069
  { node_id: node_id, location: location, receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, operator_loc: operator_loc, value: value }
8033
8070
  end
@@ -8085,7 +8122,7 @@ module Prism
8085
8122
  @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
8086
8123
  end
8087
8124
 
8088
- # attr_reader block: Prism::node?
8125
+ # attr_reader block: BlockArgumentNode?
8089
8126
  attr_reader :block
8090
8127
 
8091
8128
  # attr_reader operator_loc: Location
@@ -8196,7 +8233,7 @@ module Prism
8196
8233
  [*receiver, *call_operator_loc, opening_loc, *arguments, closing_loc, *block, binary_operator_loc, value] #: Array[Prism::node | Location]
8197
8234
  end
8198
8235
 
8199
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: Prism::node?, ?binary_operator: Symbol, ?binary_operator_loc: Location, ?value: Prism::node) -> IndexOperatorWriteNode
8236
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: BlockArgumentNode?, ?binary_operator: Symbol, ?binary_operator_loc: Location, ?value: Prism::node) -> IndexOperatorWriteNode
8200
8237
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, opening_loc: self.opening_loc, arguments: self.arguments, closing_loc: self.closing_loc, block: self.block, binary_operator: self.binary_operator, binary_operator_loc: self.binary_operator_loc, value: self.value)
8201
8238
  IndexOperatorWriteNode.new(source, node_id, location, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, binary_operator, binary_operator_loc, value)
8202
8239
  end
@@ -8204,7 +8241,7 @@ module Prism
8204
8241
  # def deconstruct: () -> Array[nil | Node]
8205
8242
  alias deconstruct child_nodes
8206
8243
 
8207
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Prism::node?, binary_operator: Symbol, binary_operator_loc: Location, value: Prism::node }
8244
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode?, binary_operator: Symbol, binary_operator_loc: Location, value: Prism::node }
8208
8245
  def deconstruct_keys(keys)
8209
8246
  { node_id: node_id, location: location, receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, binary_operator: binary_operator, binary_operator_loc: binary_operator_loc, value: value }
8210
8247
  end
@@ -8262,7 +8299,7 @@ module Prism
8262
8299
  @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
8263
8300
  end
8264
8301
 
8265
- # attr_reader block: Prism::node?
8302
+ # attr_reader block: BlockArgumentNode?
8266
8303
  attr_reader :block
8267
8304
 
8268
8305
  # attr_reader binary_operator: Symbol
@@ -8371,7 +8408,7 @@ module Prism
8371
8408
  [*receiver, *call_operator_loc, opening_loc, *arguments, closing_loc, *block, operator_loc, value] #: Array[Prism::node | Location]
8372
8409
  end
8373
8410
 
8374
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: Prism::node?, ?operator_loc: Location, ?value: Prism::node) -> IndexOrWriteNode
8411
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: BlockArgumentNode?, ?operator_loc: Location, ?value: Prism::node) -> IndexOrWriteNode
8375
8412
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, opening_loc: self.opening_loc, arguments: self.arguments, closing_loc: self.closing_loc, block: self.block, operator_loc: self.operator_loc, value: self.value)
8376
8413
  IndexOrWriteNode.new(source, node_id, location, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator_loc, value)
8377
8414
  end
@@ -8379,7 +8416,7 @@ module Prism
8379
8416
  # def deconstruct: () -> Array[nil | Node]
8380
8417
  alias deconstruct child_nodes
8381
8418
 
8382
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Prism::node?, operator_loc: Location, value: Prism::node }
8419
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode?, operator_loc: Location, value: Prism::node }
8383
8420
  def deconstruct_keys(keys)
8384
8421
  { node_id: node_id, location: location, receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, operator_loc: operator_loc, value: value }
8385
8422
  end
@@ -8437,7 +8474,7 @@ module Prism
8437
8474
  @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
8438
8475
  end
8439
8476
 
8440
- # attr_reader block: Prism::node?
8477
+ # attr_reader block: BlockArgumentNode?
8441
8478
  attr_reader :block
8442
8479
 
8443
8480
  # attr_reader operator_loc: Location
@@ -8551,7 +8588,7 @@ module Prism
8551
8588
  [receiver, opening_loc, *arguments, closing_loc, *block] #: Array[Prism::node | Location]
8552
8589
  end
8553
8590
 
8554
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: Prism::node?) -> IndexTargetNode
8591
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?receiver: Prism::node, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: BlockArgumentNode?) -> IndexTargetNode
8555
8592
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, receiver: self.receiver, opening_loc: self.opening_loc, arguments: self.arguments, closing_loc: self.closing_loc, block: self.block)
8556
8593
  IndexTargetNode.new(source, node_id, location, flags, receiver, opening_loc, arguments, closing_loc, block)
8557
8594
  end
@@ -8559,7 +8596,7 @@ module Prism
8559
8596
  # def deconstruct: () -> Array[nil | Node]
8560
8597
  alias deconstruct child_nodes
8561
8598
 
8562
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Prism::node? }
8599
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, receiver: Prism::node, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: BlockArgumentNode? }
8563
8600
  def deconstruct_keys(keys)
8564
8601
  { node_id: node_id, location: location, receiver: receiver, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block }
8565
8602
  end
@@ -8604,7 +8641,7 @@ module Prism
8604
8641
  @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
8605
8642
  end
8606
8643
 
8607
- # attr_reader block: Prism::node?
8644
+ # attr_reader block: BlockArgumentNode?
8608
8645
  attr_reader :block
8609
8646
 
8610
8647
  # def opening: () -> String
@@ -10333,7 +10370,7 @@ module Prism
10333
10370
  [operator_loc, opening_loc, closing_loc, *parameters, *body] #: Array[Prism::node | Location]
10334
10371
  end
10335
10372
 
10336
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?operator_loc: Location, ?opening_loc: Location, ?closing_loc: Location, ?parameters: Prism::node?, ?body: Prism::node?) -> LambdaNode
10373
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?operator_loc: Location, ?opening_loc: Location, ?closing_loc: Location, ?parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, ?body: StatementsNode | BeginNode | nil) -> LambdaNode
10337
10374
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, locals: self.locals, operator_loc: self.operator_loc, opening_loc: self.opening_loc, closing_loc: self.closing_loc, parameters: self.parameters, body: self.body)
10338
10375
  LambdaNode.new(source, node_id, location, flags, locals, operator_loc, opening_loc, closing_loc, parameters, body)
10339
10376
  end
@@ -10341,7 +10378,7 @@ module Prism
10341
10378
  # def deconstruct: () -> Array[nil | Node]
10342
10379
  alias deconstruct child_nodes
10343
10380
 
10344
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: Prism::node?, body: Prism::node? }
10381
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], operator_loc: Location, opening_loc: Location, closing_loc: Location, parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil, body: StatementsNode | BeginNode | nil }
10345
10382
  def deconstruct_keys(keys)
10346
10383
  { node_id: node_id, location: location, locals: locals, operator_loc: operator_loc, opening_loc: opening_loc, closing_loc: closing_loc, parameters: parameters, body: body }
10347
10384
  end
@@ -10370,10 +10407,10 @@ module Prism
10370
10407
  @closing_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
10371
10408
  end
10372
10409
 
10373
- # attr_reader parameters: Prism::node?
10410
+ # attr_reader parameters: BlockParametersNode | NumberedParametersNode | ItParametersNode | nil
10374
10411
  attr_reader :parameters
10375
10412
 
10376
- # attr_reader body: Prism::node?
10413
+ # attr_reader body: StatementsNode | BeginNode | nil
10377
10414
  attr_reader :body
10378
10415
 
10379
10416
  # def operator: () -> String
@@ -11581,7 +11618,7 @@ module Prism
11581
11618
  [module_keyword_loc, constant_path, *body, end_keyword_loc] #: Array[Prism::node | Location]
11582
11619
  end
11583
11620
 
11584
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?module_keyword_loc: Location, ?constant_path: Prism::node, ?body: Prism::node?, ?end_keyword_loc: Location, ?name: Symbol) -> ModuleNode
11621
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?module_keyword_loc: Location, ?constant_path: ConstantReadNode | ConstantPathNode | MissingNode, ?body: StatementsNode | BeginNode | nil, ?end_keyword_loc: Location, ?name: Symbol) -> ModuleNode
11585
11622
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, locals: self.locals, module_keyword_loc: self.module_keyword_loc, constant_path: self.constant_path, body: self.body, end_keyword_loc: self.end_keyword_loc, name: self.name)
11586
11623
  ModuleNode.new(source, node_id, location, flags, locals, module_keyword_loc, constant_path, body, end_keyword_loc, name)
11587
11624
  end
@@ -11589,7 +11626,7 @@ module Prism
11589
11626
  # def deconstruct: () -> Array[nil | Node]
11590
11627
  alias deconstruct child_nodes
11591
11628
 
11592
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], module_keyword_loc: Location, constant_path: Prism::node, body: Prism::node?, end_keyword_loc: Location, name: Symbol }
11629
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], module_keyword_loc: Location, constant_path: ConstantReadNode | ConstantPathNode | MissingNode, body: StatementsNode | BeginNode | nil, end_keyword_loc: Location, name: Symbol }
11593
11630
  def deconstruct_keys(keys)
11594
11631
  { node_id: node_id, location: location, locals: locals, module_keyword_loc: module_keyword_loc, constant_path: constant_path, body: body, end_keyword_loc: end_keyword_loc, name: name }
11595
11632
  end
@@ -11604,10 +11641,10 @@ module Prism
11604
11641
  @module_keyword_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
11605
11642
  end
11606
11643
 
11607
- # attr_reader constant_path: Prism::node
11644
+ # attr_reader constant_path: ConstantReadNode | ConstantPathNode | MissingNode
11608
11645
  attr_reader :constant_path
11609
11646
 
11610
- # attr_reader body: Prism::node?
11647
+ # attr_reader body: StatementsNode | BeginNode | nil
11611
11648
  attr_reader :body
11612
11649
 
11613
11650
  # attr_reader end_keyword_loc: Location
@@ -11706,7 +11743,7 @@ module Prism
11706
11743
  [*lefts, *rest, *rights, *lparen_loc, *rparen_loc] #: Array[Prism::node | Location]
11707
11744
  end
11708
11745
 
11709
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], ?rest: ImplicitRestNode | SplatNode | nil, ?rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode], ?lparen_loc: Location?, ?rparen_loc: Location?) -> MultiTargetNode
11746
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], ?rest: ImplicitRestNode | SplatNode | nil, ?rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], ?lparen_loc: Location?, ?rparen_loc: Location?) -> MultiTargetNode
11710
11747
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, lefts: self.lefts, rest: self.rest, rights: self.rights, lparen_loc: self.lparen_loc, rparen_loc: self.rparen_loc)
11711
11748
  MultiTargetNode.new(source, node_id, location, flags, lefts, rest, rights, lparen_loc, rparen_loc)
11712
11749
  end
@@ -11714,7 +11751,7 @@ module Prism
11714
11751
  # def deconstruct: () -> Array[nil | Node]
11715
11752
  alias deconstruct child_nodes
11716
11753
 
11717
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], rest: ImplicitRestNode | SplatNode | nil, rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode], lparen_loc: Location?, rparen_loc: Location? }
11754
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], rest: ImplicitRestNode | SplatNode | nil, rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | RequiredParameterNode | BackReferenceReadNode | NumberedReferenceReadNode], lparen_loc: Location?, rparen_loc: Location? }
11718
11755
  def deconstruct_keys(keys)
11719
11756
  { node_id: node_id, location: location, lefts: lefts, rest: rest, rights: rights, lparen_loc: lparen_loc, rparen_loc: rparen_loc }
11720
11757
  end
@@ -11740,7 +11777,7 @@ module Prism
11740
11777
  # a, (b, *) = 1, 2, 3, 4
11741
11778
  # ^
11742
11779
  #
11743
- # If the `*` is omitted, the field will containt an `ImplicitRestNode`
11780
+ # If the `*` is omitted, this field will contain an `ImplicitRestNode`
11744
11781
  #
11745
11782
  # a, (b,) = 1, 2, 3, 4
11746
11783
  # ^
@@ -11868,7 +11905,7 @@ module Prism
11868
11905
  [*lefts, *rest, *rights, *lparen_loc, *rparen_loc, operator_loc, value] #: Array[Prism::node | Location]
11869
11906
  end
11870
11907
 
11871
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode], ?rest: ImplicitRestNode | SplatNode | nil, ?rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode], ?lparen_loc: Location?, ?rparen_loc: Location?, ?operator_loc: Location, ?value: Prism::node) -> MultiWriteNode
11908
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode], ?rest: ImplicitRestNode | SplatNode | nil, ?rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode], ?lparen_loc: Location?, ?rparen_loc: Location?, ?operator_loc: Location, ?value: Prism::node) -> MultiWriteNode
11872
11909
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, lefts: self.lefts, rest: self.rest, rights: self.rights, lparen_loc: self.lparen_loc, rparen_loc: self.rparen_loc, operator_loc: self.operator_loc, value: self.value)
11873
11910
  MultiWriteNode.new(source, node_id, location, flags, lefts, rest, rights, lparen_loc, rparen_loc, operator_loc, value)
11874
11911
  end
@@ -11876,7 +11913,7 @@ module Prism
11876
11913
  # def deconstruct: () -> Array[nil | Node]
11877
11914
  alias deconstruct child_nodes
11878
11915
 
11879
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode], rest: ImplicitRestNode | SplatNode | nil, rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode], lparen_loc: Location?, rparen_loc: Location?, operator_loc: Location, value: Prism::node }
11916
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, lefts: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode], rest: ImplicitRestNode | SplatNode | nil, rights: Array[LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | MultiTargetNode | BackReferenceReadNode | NumberedReferenceReadNode], lparen_loc: Location?, rparen_loc: Location?, operator_loc: Location, value: Prism::node }
11880
11917
  def deconstruct_keys(keys)
11881
11918
  { node_id: node_id, location: location, lefts: lefts, rest: rest, rights: rights, lparen_loc: lparen_loc, rparen_loc: rparen_loc, operator_loc: operator_loc, value: value }
11882
11919
  end
@@ -11902,7 +11939,7 @@ module Prism
11902
11939
  # a, b, * = 1, 2, 3, 4
11903
11940
  # ^
11904
11941
  #
11905
- # If the `*` is omitted, the field will containt an `ImplicitRestNode`
11942
+ # If the `*` is omitted, this field will contain an `ImplicitRestNode`
11906
11943
  #
11907
11944
  # a, b, = 1, 2, 3, 4
11908
11945
  # ^
@@ -12674,7 +12711,7 @@ module Prism
12674
12711
  # ^
12675
12712
  attr_reader :left
12676
12713
 
12677
- # Represents the right side of the expression. It can be any [non-void expression](https://github.com/ruby/prism/blob/main/docs/parsing_rules.md#non-void-expression).
12714
+ # Represents the right side of the expression.
12678
12715
  #
12679
12716
  # left || right
12680
12717
  # ^^^^^
@@ -13092,7 +13129,7 @@ module Prism
13092
13129
  [variable, operator_loc] #: Array[Prism::node | Location]
13093
13130
  end
13094
13131
 
13095
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?variable: Prism::node, ?operator_loc: Location) -> PinnedVariableNode
13132
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?variable: LocalVariableReadNode | InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | ItLocalVariableReadNode | MissingNode, ?operator_loc: Location) -> PinnedVariableNode
13096
13133
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, variable: self.variable, operator_loc: self.operator_loc)
13097
13134
  PinnedVariableNode.new(source, node_id, location, flags, variable, operator_loc)
13098
13135
  end
@@ -13100,12 +13137,12 @@ module Prism
13100
13137
  # def deconstruct: () -> Array[nil | Node]
13101
13138
  alias deconstruct child_nodes
13102
13139
 
13103
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, variable: Prism::node, operator_loc: Location }
13140
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, variable: LocalVariableReadNode | InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | ItLocalVariableReadNode | MissingNode, operator_loc: Location }
13104
13141
  def deconstruct_keys(keys)
13105
13142
  { node_id: node_id, location: location, variable: variable, operator_loc: operator_loc }
13106
13143
  end
13107
13144
 
13108
- # attr_reader variable: Prism::node
13145
+ # attr_reader variable: LocalVariableReadNode | InstanceVariableReadNode | ClassVariableReadNode | GlobalVariableReadNode | BackReferenceReadNode | NumberedReferenceReadNode | ItLocalVariableReadNode | MissingNode
13109
13146
  attr_reader :variable
13110
13147
 
13111
13148
  # attr_reader operator_loc: Location
@@ -14223,7 +14260,7 @@ module Prism
14223
14260
  [keyword_loc, *exceptions, *operator_loc, *reference, *statements, *subsequent] #: Array[Prism::node | Location]
14224
14261
  end
14225
14262
 
14226
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?exceptions: Array[Prism::node], ?operator_loc: Location?, ?reference: Prism::node?, ?statements: StatementsNode?, ?subsequent: RescueNode?) -> RescueNode
14263
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?exceptions: Array[Prism::node], ?operator_loc: Location?, ?reference: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode | nil, ?statements: StatementsNode?, ?subsequent: RescueNode?) -> RescueNode
14227
14264
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, keyword_loc: self.keyword_loc, exceptions: self.exceptions, operator_loc: self.operator_loc, reference: self.reference, statements: self.statements, subsequent: self.subsequent)
14228
14265
  RescueNode.new(source, node_id, location, flags, keyword_loc, exceptions, operator_loc, reference, statements, subsequent)
14229
14266
  end
@@ -14231,7 +14268,7 @@ module Prism
14231
14268
  # def deconstruct: () -> Array[nil | Node]
14232
14269
  alias deconstruct child_nodes
14233
14270
 
14234
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, exceptions: Array[Prism::node], operator_loc: Location?, reference: Prism::node?, statements: StatementsNode?, subsequent: RescueNode? }
14271
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, exceptions: Array[Prism::node], operator_loc: Location?, reference: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode | nil, statements: StatementsNode?, subsequent: RescueNode? }
14235
14272
  def deconstruct_keys(keys)
14236
14273
  { node_id: node_id, location: location, keyword_loc: keyword_loc, exceptions: exceptions, operator_loc: operator_loc, reference: reference, statements: statements, subsequent: subsequent }
14237
14274
  end
@@ -14259,7 +14296,7 @@ module Prism
14259
14296
  end
14260
14297
  end
14261
14298
 
14262
- # attr_reader reference: Prism::node?
14299
+ # attr_reader reference: LocalVariableTargetNode | InstanceVariableTargetNode | ClassVariableTargetNode | GlobalVariableTargetNode | ConstantTargetNode | ConstantPathTargetNode | CallTargetNode | IndexTargetNode | BackReferenceReadNode | NumberedReferenceReadNode | MissingNode | nil
14263
14300
  attr_reader :reference
14264
14301
 
14265
14302
  # attr_reader statements: StatementsNode?
@@ -14773,7 +14810,7 @@ module Prism
14773
14810
  [class_keyword_loc, operator_loc, expression, *body, end_keyword_loc] #: Array[Prism::node | Location]
14774
14811
  end
14775
14812
 
14776
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?class_keyword_loc: Location, ?operator_loc: Location, ?expression: Prism::node, ?body: Prism::node?, ?end_keyword_loc: Location) -> SingletonClassNode
14813
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?locals: Array[Symbol], ?class_keyword_loc: Location, ?operator_loc: Location, ?expression: Prism::node, ?body: StatementsNode | BeginNode | nil, ?end_keyword_loc: Location) -> SingletonClassNode
14777
14814
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, locals: self.locals, class_keyword_loc: self.class_keyword_loc, operator_loc: self.operator_loc, expression: self.expression, body: self.body, end_keyword_loc: self.end_keyword_loc)
14778
14815
  SingletonClassNode.new(source, node_id, location, flags, locals, class_keyword_loc, operator_loc, expression, body, end_keyword_loc)
14779
14816
  end
@@ -14781,7 +14818,7 @@ module Prism
14781
14818
  # def deconstruct: () -> Array[nil | Node]
14782
14819
  alias deconstruct child_nodes
14783
14820
 
14784
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Prism::node, body: Prism::node?, end_keyword_loc: Location }
14821
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, locals: Array[Symbol], class_keyword_loc: Location, operator_loc: Location, expression: Prism::node, body: StatementsNode | BeginNode | nil, end_keyword_loc: Location }
14785
14822
  def deconstruct_keys(keys)
14786
14823
  { node_id: node_id, location: location, locals: locals, class_keyword_loc: class_keyword_loc, operator_loc: operator_loc, expression: expression, body: body, end_keyword_loc: end_keyword_loc }
14787
14824
  end
@@ -14806,7 +14843,7 @@ module Prism
14806
14843
  # attr_reader expression: Prism::node
14807
14844
  attr_reader :expression
14808
14845
 
14809
- # attr_reader body: Prism::node?
14846
+ # attr_reader body: StatementsNode | BeginNode | nil
14810
14847
  attr_reader :body
14811
14848
 
14812
14849
  # attr_reader end_keyword_loc: Location
@@ -15451,7 +15488,7 @@ module Prism
15451
15488
  [keyword_loc, *lparen_loc, *arguments, *rparen_loc, *block] #: Array[Prism::node | Location]
15452
15489
  end
15453
15490
 
15454
- # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?lparen_loc: Location?, ?arguments: ArgumentsNode?, ?rparen_loc: Location?, ?block: Prism::node?) -> SuperNode
15491
+ # def copy: (?node_id: Integer, ?location: Location, ?flags: Integer, ?keyword_loc: Location, ?lparen_loc: Location?, ?arguments: ArgumentsNode?, ?rparen_loc: Location?, ?block: BlockNode | BlockArgumentNode | nil) -> SuperNode
15455
15492
  def copy(node_id: self.node_id, location: self.location, flags: self.flags, keyword_loc: self.keyword_loc, lparen_loc: self.lparen_loc, arguments: self.arguments, rparen_loc: self.rparen_loc, block: self.block)
15456
15493
  SuperNode.new(source, node_id, location, flags, keyword_loc, lparen_loc, arguments, rparen_loc, block)
15457
15494
  end
@@ -15459,7 +15496,7 @@ module Prism
15459
15496
  # def deconstruct: () -> Array[nil | Node]
15460
15497
  alias deconstruct child_nodes
15461
15498
 
15462
- # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, block: Prism::node? }
15499
+ # def deconstruct_keys: (Array[Symbol] keys) -> { node_id: Integer, location: Location, keyword_loc: Location, lparen_loc: Location?, arguments: ArgumentsNode?, rparen_loc: Location?, block: BlockNode | BlockArgumentNode | nil }
15463
15500
  def deconstruct_keys(keys)
15464
15501
  { node_id: node_id, location: location, keyword_loc: keyword_loc, lparen_loc: lparen_loc, arguments: arguments, rparen_loc: rparen_loc, block: block }
15465
15502
  end
@@ -15500,7 +15537,7 @@ module Prism
15500
15537
  end
15501
15538
  end
15502
15539
 
15503
- # attr_reader block: Prism::node?
15540
+ # attr_reader block: BlockNode | BlockArgumentNode | nil
15504
15541
  attr_reader :block
15505
15542
 
15506
15543
  # def keyword: () -> String
@@ -16645,14 +16682,20 @@ module Prism
16645
16682
 
16646
16683
  # Flags for arguments nodes.
16647
16684
  module ArgumentsNodeFlags
16648
- # if arguments contain keywords
16649
- CONTAINS_KEYWORDS = 1 << 2
16685
+ # if the arguments contain forwarding
16686
+ CONTAINS_FORWARDING = 1 << 2
16687
+
16688
+ # if the arguments contain keywords
16689
+ CONTAINS_KEYWORDS = 1 << 3
16690
+
16691
+ # if the arguments contain a keyword splat
16692
+ CONTAINS_KEYWORD_SPLAT = 1 << 4
16650
16693
 
16651
- # if arguments contain keyword splat
16652
- CONTAINS_KEYWORD_SPLAT = 1 << 3
16694
+ # if the arguments contain a splat
16695
+ CONTAINS_SPLAT = 1 << 5
16653
16696
 
16654
- # if arguments contain splat
16655
- CONTAINS_SPLAT = 1 << 4
16697
+ # if the arguments contain multiple splats
16698
+ CONTAINS_MULTIPLE_SPLATS = 1 << 6
16656
16699
  end
16657
16700
 
16658
16701
  # Flags for array nodes.