prism 0.28.0 → 0.29.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
@@ -2716,8 +2716,8 @@ module Prism
2716
2716
  # foo.bar += baz
2717
2717
  # ^^^^^^^^^^^^^^
2718
2718
  class CallOperatorWriteNode < Node
2719
- # def initialize: (Integer flags, Prism::node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Symbol operator, Location operator_loc, Prism::node value, Location location) -> void
2720
- def initialize(source, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator, operator_loc, value, location)
2719
+ # def initialize: (Integer flags, Prism::node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Symbol binary_operator, Location binary_operator_loc, Prism::node value, Location location) -> void
2720
+ def initialize(source, flags, receiver, call_operator_loc, message_loc, read_name, write_name, binary_operator, binary_operator_loc, value, location)
2721
2721
  @source = source
2722
2722
  @newline = false
2723
2723
  @location = location
@@ -2727,8 +2727,8 @@ module Prism
2727
2727
  @message_loc = message_loc
2728
2728
  @read_name = read_name
2729
2729
  @write_name = write_name
2730
- @operator = operator
2731
- @operator_loc = operator_loc
2730
+ @binary_operator = binary_operator
2731
+ @binary_operator_loc = binary_operator_loc
2732
2732
  @value = value
2733
2733
  end
2734
2734
 
@@ -2752,20 +2752,20 @@ module Prism
2752
2752
 
2753
2753
  # def comment_targets: () -> Array[Node | Location]
2754
2754
  def comment_targets
2755
- [*receiver, *call_operator_loc, *message_loc, operator_loc, value] #: Array[Prism::node | Location]
2755
+ [*receiver, *call_operator_loc, *message_loc, binary_operator_loc, value] #: Array[Prism::node | Location]
2756
2756
  end
2757
2757
 
2758
- # def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?operator: Symbol, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> CallOperatorWriteNode
2759
- def copy(flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, message_loc: self.message_loc, read_name: self.read_name, write_name: self.write_name, operator: self.operator, operator_loc: self.operator_loc, value: self.value, location: self.location)
2760
- CallOperatorWriteNode.new(source, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator, operator_loc, value, location)
2758
+ # def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?message_loc: Location?, ?read_name: Symbol, ?write_name: Symbol, ?binary_operator: Symbol, ?binary_operator_loc: Location, ?value: Prism::node, ?location: Location) -> CallOperatorWriteNode
2759
+ def copy(flags: self.flags, receiver: self.receiver, call_operator_loc: self.call_operator_loc, message_loc: self.message_loc, read_name: self.read_name, write_name: self.write_name, binary_operator: self.binary_operator, binary_operator_loc: self.binary_operator_loc, value: self.value, location: self.location)
2760
+ CallOperatorWriteNode.new(source, flags, receiver, call_operator_loc, message_loc, read_name, write_name, binary_operator, binary_operator_loc, value, location)
2761
2761
  end
2762
2762
 
2763
2763
  # def deconstruct: () -> Array[nil | Node]
2764
2764
  alias deconstruct child_nodes
2765
2765
 
2766
- # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Location, value: Prism::node, location: Location }
2766
+ # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, message_loc: Location?, read_name: Symbol, write_name: Symbol, binary_operator: Symbol, binary_operator_loc: Location, value: Prism::node, location: Location }
2767
2767
  def deconstruct_keys(keys)
2768
- { flags: flags, receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, read_name: read_name, write_name: write_name, operator: operator, operator_loc: operator_loc, value: value, location: location }
2768
+ { flags: flags, receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, read_name: read_name, write_name: write_name, binary_operator: binary_operator, binary_operator_loc: binary_operator_loc, value: value, location: location }
2769
2769
  end
2770
2770
 
2771
2771
  # protected attr_reader flags: Integer
@@ -2807,14 +2807,14 @@ module Prism
2807
2807
  # attr_reader write_name: Symbol
2808
2808
  attr_reader :write_name
2809
2809
 
2810
- # attr_reader operator: Symbol
2811
- attr_reader :operator
2810
+ # attr_reader binary_operator: Symbol
2811
+ attr_reader :binary_operator
2812
2812
 
2813
- # attr_reader operator_loc: Location
2814
- def operator_loc
2815
- location = @operator_loc
2813
+ # attr_reader binary_operator_loc: Location
2814
+ def binary_operator_loc
2815
+ location = @binary_operator_loc
2816
2816
  return location if location.is_a?(Location)
2817
- @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
2817
+ @binary_operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
2818
2818
  end
2819
2819
 
2820
2820
  # attr_reader value: Prism::node
@@ -2893,8 +2893,8 @@ module Prism
2893
2893
  (message_loc.nil? == other.message_loc.nil?) &&
2894
2894
  (read_name === other.read_name) &&
2895
2895
  (write_name === other.write_name) &&
2896
- (operator === other.operator) &&
2897
- (operator_loc.nil? == other.operator_loc.nil?) &&
2896
+ (binary_operator === other.binary_operator) &&
2897
+ (binary_operator_loc.nil? == other.binary_operator_loc.nil?) &&
2898
2898
  (value === other.value)
2899
2899
  end
2900
2900
  end
@@ -3909,16 +3909,16 @@ module Prism
3909
3909
  # @@target += value
3910
3910
  # ^^^^^^^^^^^^^^^^^
3911
3911
  class ClassVariableOperatorWriteNode < Node
3912
- # def initialize: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Symbol operator, Location location) -> void
3913
- def initialize(source, name, name_loc, operator_loc, value, operator, location)
3912
+ # def initialize: (Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator, Location location) -> void
3913
+ def initialize(source, name, name_loc, binary_operator_loc, value, binary_operator, location)
3914
3914
  @source = source
3915
3915
  @newline = false
3916
3916
  @location = location
3917
3917
  @name = name
3918
3918
  @name_loc = name_loc
3919
- @operator_loc = operator_loc
3919
+ @binary_operator_loc = binary_operator_loc
3920
3920
  @value = value
3921
- @operator = operator
3921
+ @binary_operator = binary_operator
3922
3922
  end
3923
3923
 
3924
3924
  # def accept: (Visitor visitor) -> void
@@ -3938,20 +3938,20 @@ module Prism
3938
3938
 
3939
3939
  # def comment_targets: () -> Array[Node | Location]
3940
3940
  def comment_targets
3941
- [name_loc, operator_loc, value] #: Array[Prism::node | Location]
3941
+ [name_loc, binary_operator_loc, value] #: Array[Prism::node | Location]
3942
3942
  end
3943
3943
 
3944
- # def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?operator: Symbol, ?location: Location) -> ClassVariableOperatorWriteNode
3945
- def copy(name: self.name, name_loc: self.name_loc, operator_loc: self.operator_loc, value: self.value, operator: self.operator, location: self.location)
3946
- ClassVariableOperatorWriteNode.new(source, name, name_loc, operator_loc, value, operator, location)
3944
+ # def copy: (?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol, ?location: Location) -> ClassVariableOperatorWriteNode
3945
+ def copy(name: self.name, name_loc: self.name_loc, binary_operator_loc: self.binary_operator_loc, value: self.value, binary_operator: self.binary_operator, location: self.location)
3946
+ ClassVariableOperatorWriteNode.new(source, name, name_loc, binary_operator_loc, value, binary_operator, location)
3947
3947
  end
3948
3948
 
3949
3949
  # def deconstruct: () -> Array[nil | Node]
3950
3950
  alias deconstruct child_nodes
3951
3951
 
3952
- # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, operator: Symbol, location: Location }
3952
+ # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol, location: Location }
3953
3953
  def deconstruct_keys(keys)
3954
- { name: name, name_loc: name_loc, operator_loc: operator_loc, value: value, operator: operator, location: location }
3954
+ { name: name, name_loc: name_loc, binary_operator_loc: binary_operator_loc, value: value, binary_operator: binary_operator, location: location }
3955
3955
  end
3956
3956
 
3957
3957
  # attr_reader name: Symbol
@@ -3964,18 +3964,18 @@ module Prism
3964
3964
  @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
3965
3965
  end
3966
3966
 
3967
- # attr_reader operator_loc: Location
3968
- def operator_loc
3969
- location = @operator_loc
3967
+ # attr_reader binary_operator_loc: Location
3968
+ def binary_operator_loc
3969
+ location = @binary_operator_loc
3970
3970
  return location if location.is_a?(Location)
3971
- @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
3971
+ @binary_operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
3972
3972
  end
3973
3973
 
3974
3974
  # attr_reader value: Prism::node
3975
3975
  attr_reader :value
3976
3976
 
3977
- # attr_reader operator: Symbol
3978
- attr_reader :operator
3977
+ # attr_reader binary_operator: Symbol
3978
+ attr_reader :binary_operator
3979
3979
 
3980
3980
  # def inspect -> String
3981
3981
  def inspect
@@ -4016,9 +4016,9 @@ module Prism
4016
4016
  other.is_a?(ClassVariableOperatorWriteNode) &&
4017
4017
  (name === other.name) &&
4018
4018
  (name_loc.nil? == other.name_loc.nil?) &&
4019
- (operator_loc.nil? == other.operator_loc.nil?) &&
4019
+ (binary_operator_loc.nil? == other.binary_operator_loc.nil?) &&
4020
4020
  (value === other.value) &&
4021
- (operator === other.operator)
4021
+ (binary_operator === other.binary_operator)
4022
4022
  end
4023
4023
  end
4024
4024
 
@@ -4581,16 +4581,16 @@ module Prism
4581
4581
  # Target += value
4582
4582
  # ^^^^^^^^^^^^^^^
4583
4583
  class ConstantOperatorWriteNode < Node
4584
- # def initialize: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Symbol operator, Location location) -> void
4585
- def initialize(source, name, name_loc, operator_loc, value, operator, location)
4584
+ # def initialize: (Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator, Location location) -> void
4585
+ def initialize(source, name, name_loc, binary_operator_loc, value, binary_operator, location)
4586
4586
  @source = source
4587
4587
  @newline = false
4588
4588
  @location = location
4589
4589
  @name = name
4590
4590
  @name_loc = name_loc
4591
- @operator_loc = operator_loc
4591
+ @binary_operator_loc = binary_operator_loc
4592
4592
  @value = value
4593
- @operator = operator
4593
+ @binary_operator = binary_operator
4594
4594
  end
4595
4595
 
4596
4596
  # def accept: (Visitor visitor) -> void
@@ -4610,20 +4610,20 @@ module Prism
4610
4610
 
4611
4611
  # def comment_targets: () -> Array[Node | Location]
4612
4612
  def comment_targets
4613
- [name_loc, operator_loc, value] #: Array[Prism::node | Location]
4613
+ [name_loc, binary_operator_loc, value] #: Array[Prism::node | Location]
4614
4614
  end
4615
4615
 
4616
- # def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?operator: Symbol, ?location: Location) -> ConstantOperatorWriteNode
4617
- def copy(name: self.name, name_loc: self.name_loc, operator_loc: self.operator_loc, value: self.value, operator: self.operator, location: self.location)
4618
- ConstantOperatorWriteNode.new(source, name, name_loc, operator_loc, value, operator, location)
4616
+ # def copy: (?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol, ?location: Location) -> ConstantOperatorWriteNode
4617
+ def copy(name: self.name, name_loc: self.name_loc, binary_operator_loc: self.binary_operator_loc, value: self.value, binary_operator: self.binary_operator, location: self.location)
4618
+ ConstantOperatorWriteNode.new(source, name, name_loc, binary_operator_loc, value, binary_operator, location)
4619
4619
  end
4620
4620
 
4621
4621
  # def deconstruct: () -> Array[nil | Node]
4622
4622
  alias deconstruct child_nodes
4623
4623
 
4624
- # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, operator: Symbol, location: Location }
4624
+ # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol, location: Location }
4625
4625
  def deconstruct_keys(keys)
4626
- { name: name, name_loc: name_loc, operator_loc: operator_loc, value: value, operator: operator, location: location }
4626
+ { name: name, name_loc: name_loc, binary_operator_loc: binary_operator_loc, value: value, binary_operator: binary_operator, location: location }
4627
4627
  end
4628
4628
 
4629
4629
  # attr_reader name: Symbol
@@ -4636,18 +4636,18 @@ module Prism
4636
4636
  @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
4637
4637
  end
4638
4638
 
4639
- # attr_reader operator_loc: Location
4640
- def operator_loc
4641
- location = @operator_loc
4639
+ # attr_reader binary_operator_loc: Location
4640
+ def binary_operator_loc
4641
+ location = @binary_operator_loc
4642
4642
  return location if location.is_a?(Location)
4643
- @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
4643
+ @binary_operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
4644
4644
  end
4645
4645
 
4646
4646
  # attr_reader value: Prism::node
4647
4647
  attr_reader :value
4648
4648
 
4649
- # attr_reader operator: Symbol
4650
- attr_reader :operator
4649
+ # attr_reader binary_operator: Symbol
4650
+ attr_reader :binary_operator
4651
4651
 
4652
4652
  # def inspect -> String
4653
4653
  def inspect
@@ -4688,9 +4688,9 @@ module Prism
4688
4688
  other.is_a?(ConstantOperatorWriteNode) &&
4689
4689
  (name === other.name) &&
4690
4690
  (name_loc.nil? == other.name_loc.nil?) &&
4691
- (operator_loc.nil? == other.operator_loc.nil?) &&
4691
+ (binary_operator_loc.nil? == other.binary_operator_loc.nil?) &&
4692
4692
  (value === other.value) &&
4693
- (operator === other.operator)
4693
+ (binary_operator === other.binary_operator)
4694
4694
  end
4695
4695
  end
4696
4696
 
@@ -5067,15 +5067,15 @@ module Prism
5067
5067
  # Parent::Child += value
5068
5068
  # ^^^^^^^^^^^^^^^^^^^^^^
5069
5069
  class ConstantPathOperatorWriteNode < Node
5070
- # def initialize: (ConstantPathNode target, Location operator_loc, Prism::node value, Symbol operator, Location location) -> void
5071
- def initialize(source, target, operator_loc, value, operator, location)
5070
+ # def initialize: (ConstantPathNode target, Location binary_operator_loc, Prism::node value, Symbol binary_operator, Location location) -> void
5071
+ def initialize(source, target, binary_operator_loc, value, binary_operator, location)
5072
5072
  @source = source
5073
5073
  @newline = false
5074
5074
  @location = location
5075
5075
  @target = target
5076
- @operator_loc = operator_loc
5076
+ @binary_operator_loc = binary_operator_loc
5077
5077
  @value = value
5078
- @operator = operator
5078
+ @binary_operator = binary_operator
5079
5079
  end
5080
5080
 
5081
5081
  # def accept: (Visitor visitor) -> void
@@ -5095,37 +5095,37 @@ module Prism
5095
5095
 
5096
5096
  # def comment_targets: () -> Array[Node | Location]
5097
5097
  def comment_targets
5098
- [target, operator_loc, value] #: Array[Prism::node | Location]
5098
+ [target, binary_operator_loc, value] #: Array[Prism::node | Location]
5099
5099
  end
5100
5100
 
5101
- # def copy: (?target: ConstantPathNode, ?operator_loc: Location, ?value: Prism::node, ?operator: Symbol, ?location: Location) -> ConstantPathOperatorWriteNode
5102
- def copy(target: self.target, operator_loc: self.operator_loc, value: self.value, operator: self.operator, location: self.location)
5103
- ConstantPathOperatorWriteNode.new(source, target, operator_loc, value, operator, location)
5101
+ # def copy: (?target: ConstantPathNode, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol, ?location: Location) -> ConstantPathOperatorWriteNode
5102
+ def copy(target: self.target, binary_operator_loc: self.binary_operator_loc, value: self.value, binary_operator: self.binary_operator, location: self.location)
5103
+ ConstantPathOperatorWriteNode.new(source, target, binary_operator_loc, value, binary_operator, location)
5104
5104
  end
5105
5105
 
5106
5106
  # def deconstruct: () -> Array[nil | Node]
5107
5107
  alias deconstruct child_nodes
5108
5108
 
5109
- # def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, operator_loc: Location, value: Prism::node, operator: Symbol, location: Location }
5109
+ # def deconstruct_keys: (Array[Symbol] keys) -> { target: ConstantPathNode, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol, location: Location }
5110
5110
  def deconstruct_keys(keys)
5111
- { target: target, operator_loc: operator_loc, value: value, operator: operator, location: location }
5111
+ { target: target, binary_operator_loc: binary_operator_loc, value: value, binary_operator: binary_operator, location: location }
5112
5112
  end
5113
5113
 
5114
5114
  # attr_reader target: ConstantPathNode
5115
5115
  attr_reader :target
5116
5116
 
5117
- # attr_reader operator_loc: Location
5118
- def operator_loc
5119
- location = @operator_loc
5117
+ # attr_reader binary_operator_loc: Location
5118
+ def binary_operator_loc
5119
+ location = @binary_operator_loc
5120
5120
  return location if location.is_a?(Location)
5121
- @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
5121
+ @binary_operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
5122
5122
  end
5123
5123
 
5124
5124
  # attr_reader value: Prism::node
5125
5125
  attr_reader :value
5126
5126
 
5127
- # attr_reader operator: Symbol
5128
- attr_reader :operator
5127
+ # attr_reader binary_operator: Symbol
5128
+ attr_reader :binary_operator
5129
5129
 
5130
5130
  # def inspect -> String
5131
5131
  def inspect
@@ -5165,9 +5165,9 @@ module Prism
5165
5165
  def ===(other)
5166
5166
  other.is_a?(ConstantPathOperatorWriteNode) &&
5167
5167
  (target === other.target) &&
5168
- (operator_loc.nil? == other.operator_loc.nil?) &&
5168
+ (binary_operator_loc.nil? == other.binary_operator_loc.nil?) &&
5169
5169
  (value === other.value) &&
5170
- (operator === other.operator)
5170
+ (binary_operator === other.binary_operator)
5171
5171
  end
5172
5172
  end
5173
5173
 
@@ -7711,16 +7711,16 @@ module Prism
7711
7711
  # $target += value
7712
7712
  # ^^^^^^^^^^^^^^^^
7713
7713
  class GlobalVariableOperatorWriteNode < Node
7714
- # def initialize: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Symbol operator, Location location) -> void
7715
- def initialize(source, name, name_loc, operator_loc, value, operator, location)
7714
+ # def initialize: (Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator, Location location) -> void
7715
+ def initialize(source, name, name_loc, binary_operator_loc, value, binary_operator, location)
7716
7716
  @source = source
7717
7717
  @newline = false
7718
7718
  @location = location
7719
7719
  @name = name
7720
7720
  @name_loc = name_loc
7721
- @operator_loc = operator_loc
7721
+ @binary_operator_loc = binary_operator_loc
7722
7722
  @value = value
7723
- @operator = operator
7723
+ @binary_operator = binary_operator
7724
7724
  end
7725
7725
 
7726
7726
  # def accept: (Visitor visitor) -> void
@@ -7740,20 +7740,20 @@ module Prism
7740
7740
 
7741
7741
  # def comment_targets: () -> Array[Node | Location]
7742
7742
  def comment_targets
7743
- [name_loc, operator_loc, value] #: Array[Prism::node | Location]
7743
+ [name_loc, binary_operator_loc, value] #: Array[Prism::node | Location]
7744
7744
  end
7745
7745
 
7746
- # def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?operator: Symbol, ?location: Location) -> GlobalVariableOperatorWriteNode
7747
- def copy(name: self.name, name_loc: self.name_loc, operator_loc: self.operator_loc, value: self.value, operator: self.operator, location: self.location)
7748
- GlobalVariableOperatorWriteNode.new(source, name, name_loc, operator_loc, value, operator, location)
7746
+ # def copy: (?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol, ?location: Location) -> GlobalVariableOperatorWriteNode
7747
+ def copy(name: self.name, name_loc: self.name_loc, binary_operator_loc: self.binary_operator_loc, value: self.value, binary_operator: self.binary_operator, location: self.location)
7748
+ GlobalVariableOperatorWriteNode.new(source, name, name_loc, binary_operator_loc, value, binary_operator, location)
7749
7749
  end
7750
7750
 
7751
7751
  # def deconstruct: () -> Array[nil | Node]
7752
7752
  alias deconstruct child_nodes
7753
7753
 
7754
- # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, operator: Symbol, location: Location }
7754
+ # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol, location: Location }
7755
7755
  def deconstruct_keys(keys)
7756
- { name: name, name_loc: name_loc, operator_loc: operator_loc, value: value, operator: operator, location: location }
7756
+ { name: name, name_loc: name_loc, binary_operator_loc: binary_operator_loc, value: value, binary_operator: binary_operator, location: location }
7757
7757
  end
7758
7758
 
7759
7759
  # attr_reader name: Symbol
@@ -7766,18 +7766,18 @@ module Prism
7766
7766
  @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
7767
7767
  end
7768
7768
 
7769
- # attr_reader operator_loc: Location
7770
- def operator_loc
7771
- location = @operator_loc
7769
+ # attr_reader binary_operator_loc: Location
7770
+ def binary_operator_loc
7771
+ location = @binary_operator_loc
7772
7772
  return location if location.is_a?(Location)
7773
- @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
7773
+ @binary_operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
7774
7774
  end
7775
7775
 
7776
7776
  # attr_reader value: Prism::node
7777
7777
  attr_reader :value
7778
7778
 
7779
- # attr_reader operator: Symbol
7780
- attr_reader :operator
7779
+ # attr_reader binary_operator: Symbol
7780
+ attr_reader :binary_operator
7781
7781
 
7782
7782
  # def inspect -> String
7783
7783
  def inspect
@@ -7818,9 +7818,9 @@ module Prism
7818
7818
  other.is_a?(GlobalVariableOperatorWriteNode) &&
7819
7819
  (name === other.name) &&
7820
7820
  (name_loc.nil? == other.name_loc.nil?) &&
7821
- (operator_loc.nil? == other.operator_loc.nil?) &&
7821
+ (binary_operator_loc.nil? == other.binary_operator_loc.nil?) &&
7822
7822
  (value === other.value) &&
7823
- (operator === other.operator)
7823
+ (binary_operator === other.binary_operator)
7824
7824
  end
7825
7825
  end
7826
7826
 
@@ -9374,8 +9374,8 @@ module Prism
9374
9374
  # foo.bar[baz] += value
9375
9375
  # ^^^^^^^^^^^^^^^^^^^^^
9376
9376
  class IndexOperatorWriteNode < Node
9377
- # def initialize: (Integer flags, Prism::node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Prism::node? block, Symbol operator, Location operator_loc, Prism::node value, Location location) -> void
9378
- def initialize(source, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator, operator_loc, value, location)
9377
+ # def initialize: (Integer flags, Prism::node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Prism::node? block, Symbol binary_operator, Location binary_operator_loc, Prism::node value, Location location) -> void
9378
+ def initialize(source, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, binary_operator, binary_operator_loc, value, location)
9379
9379
  @source = source
9380
9380
  @newline = false
9381
9381
  @location = location
@@ -9386,8 +9386,8 @@ module Prism
9386
9386
  @arguments = arguments
9387
9387
  @closing_loc = closing_loc
9388
9388
  @block = block
9389
- @operator = operator
9390
- @operator_loc = operator_loc
9389
+ @binary_operator = binary_operator
9390
+ @binary_operator_loc = binary_operator_loc
9391
9391
  @value = value
9392
9392
  end
9393
9393
 
@@ -9413,20 +9413,20 @@ module Prism
9413
9413
 
9414
9414
  # def comment_targets: () -> Array[Node | Location]
9415
9415
  def comment_targets
9416
- [*receiver, *call_operator_loc, opening_loc, *arguments, closing_loc, *block, operator_loc, value] #: Array[Prism::node | Location]
9416
+ [*receiver, *call_operator_loc, opening_loc, *arguments, closing_loc, *block, binary_operator_loc, value] #: Array[Prism::node | Location]
9417
9417
  end
9418
9418
 
9419
- # def copy: (?flags: Integer, ?receiver: Prism::node?, ?call_operator_loc: Location?, ?opening_loc: Location, ?arguments: ArgumentsNode?, ?closing_loc: Location, ?block: Prism::node?, ?operator: Symbol, ?operator_loc: Location, ?value: Prism::node, ?location: Location) -> IndexOperatorWriteNode
9420
- def copy(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: self.operator, operator_loc: self.operator_loc, value: self.value, location: self.location)
9421
- IndexOperatorWriteNode.new(source, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator, operator_loc, value, location)
9419
+ # def copy: (?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, ?location: Location) -> IndexOperatorWriteNode
9420
+ def copy(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, location: self.location)
9421
+ IndexOperatorWriteNode.new(source, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, binary_operator, binary_operator_loc, value, location)
9422
9422
  end
9423
9423
 
9424
9424
  # def deconstruct: () -> Array[nil | Node]
9425
9425
  alias deconstruct child_nodes
9426
9426
 
9427
- # def deconstruct_keys: (Array[Symbol] keys) -> { flags: Integer, receiver: Prism::node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Prism::node?, operator: Symbol, operator_loc: Location, value: Prism::node, location: Location }
9427
+ # def deconstruct_keys: (Array[Symbol] keys) -> { 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, location: Location }
9428
9428
  def deconstruct_keys(keys)
9429
- { flags: flags, receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, operator: operator, operator_loc: operator_loc, value: value, location: location }
9429
+ { flags: flags, 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, location: location }
9430
9430
  end
9431
9431
 
9432
9432
  # protected attr_reader flags: Integer
@@ -9469,14 +9469,14 @@ module Prism
9469
9469
  # attr_reader block: Prism::node?
9470
9470
  attr_reader :block
9471
9471
 
9472
- # attr_reader operator: Symbol
9473
- attr_reader :operator
9472
+ # attr_reader binary_operator: Symbol
9473
+ attr_reader :binary_operator
9474
9474
 
9475
- # attr_reader operator_loc: Location
9476
- def operator_loc
9477
- location = @operator_loc
9475
+ # attr_reader binary_operator_loc: Location
9476
+ def binary_operator_loc
9477
+ location = @binary_operator_loc
9478
9478
  return location if location.is_a?(Location)
9479
- @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
9479
+ @binary_operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
9480
9480
  end
9481
9481
 
9482
9482
  # attr_reader value: Prism::node
@@ -9561,8 +9561,8 @@ module Prism
9561
9561
  (arguments === other.arguments) &&
9562
9562
  (closing_loc.nil? == other.closing_loc.nil?) &&
9563
9563
  (block === other.block) &&
9564
- (operator === other.operator) &&
9565
- (operator_loc.nil? == other.operator_loc.nil?) &&
9564
+ (binary_operator === other.binary_operator) &&
9565
+ (binary_operator_loc.nil? == other.binary_operator_loc.nil?) &&
9566
9566
  (value === other.value)
9567
9567
  end
9568
9568
  end
@@ -10054,16 +10054,16 @@ module Prism
10054
10054
  # @target += value
10055
10055
  # ^^^^^^^^^^^^^^^^
10056
10056
  class InstanceVariableOperatorWriteNode < Node
10057
- # def initialize: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Symbol operator, Location location) -> void
10058
- def initialize(source, name, name_loc, operator_loc, value, operator, location)
10057
+ # def initialize: (Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator, Location location) -> void
10058
+ def initialize(source, name, name_loc, binary_operator_loc, value, binary_operator, location)
10059
10059
  @source = source
10060
10060
  @newline = false
10061
10061
  @location = location
10062
10062
  @name = name
10063
10063
  @name_loc = name_loc
10064
- @operator_loc = operator_loc
10064
+ @binary_operator_loc = binary_operator_loc
10065
10065
  @value = value
10066
- @operator = operator
10066
+ @binary_operator = binary_operator
10067
10067
  end
10068
10068
 
10069
10069
  # def accept: (Visitor visitor) -> void
@@ -10083,20 +10083,20 @@ module Prism
10083
10083
 
10084
10084
  # def comment_targets: () -> Array[Node | Location]
10085
10085
  def comment_targets
10086
- [name_loc, operator_loc, value] #: Array[Prism::node | Location]
10086
+ [name_loc, binary_operator_loc, value] #: Array[Prism::node | Location]
10087
10087
  end
10088
10088
 
10089
- # def copy: (?name: Symbol, ?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?operator: Symbol, ?location: Location) -> InstanceVariableOperatorWriteNode
10090
- def copy(name: self.name, name_loc: self.name_loc, operator_loc: self.operator_loc, value: self.value, operator: self.operator, location: self.location)
10091
- InstanceVariableOperatorWriteNode.new(source, name, name_loc, operator_loc, value, operator, location)
10089
+ # def copy: (?name: Symbol, ?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?binary_operator: Symbol, ?location: Location) -> InstanceVariableOperatorWriteNode
10090
+ def copy(name: self.name, name_loc: self.name_loc, binary_operator_loc: self.binary_operator_loc, value: self.value, binary_operator: self.binary_operator, location: self.location)
10091
+ InstanceVariableOperatorWriteNode.new(source, name, name_loc, binary_operator_loc, value, binary_operator, location)
10092
10092
  end
10093
10093
 
10094
10094
  # def deconstruct: () -> Array[nil | Node]
10095
10095
  alias deconstruct child_nodes
10096
10096
 
10097
- # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, operator_loc: Location, value: Prism::node, operator: Symbol, location: Location }
10097
+ # def deconstruct_keys: (Array[Symbol] keys) -> { name: Symbol, name_loc: Location, binary_operator_loc: Location, value: Prism::node, binary_operator: Symbol, location: Location }
10098
10098
  def deconstruct_keys(keys)
10099
- { name: name, name_loc: name_loc, operator_loc: operator_loc, value: value, operator: operator, location: location }
10099
+ { name: name, name_loc: name_loc, binary_operator_loc: binary_operator_loc, value: value, binary_operator: binary_operator, location: location }
10100
10100
  end
10101
10101
 
10102
10102
  # attr_reader name: Symbol
@@ -10109,18 +10109,18 @@ module Prism
10109
10109
  @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
10110
10110
  end
10111
10111
 
10112
- # attr_reader operator_loc: Location
10113
- def operator_loc
10114
- location = @operator_loc
10112
+ # attr_reader binary_operator_loc: Location
10113
+ def binary_operator_loc
10114
+ location = @binary_operator_loc
10115
10115
  return location if location.is_a?(Location)
10116
- @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
10116
+ @binary_operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
10117
10117
  end
10118
10118
 
10119
10119
  # attr_reader value: Prism::node
10120
10120
  attr_reader :value
10121
10121
 
10122
- # attr_reader operator: Symbol
10123
- attr_reader :operator
10122
+ # attr_reader binary_operator: Symbol
10123
+ attr_reader :binary_operator
10124
10124
 
10125
10125
  # def inspect -> String
10126
10126
  def inspect
@@ -10161,9 +10161,9 @@ module Prism
10161
10161
  other.is_a?(InstanceVariableOperatorWriteNode) &&
10162
10162
  (name === other.name) &&
10163
10163
  (name_loc.nil? == other.name_loc.nil?) &&
10164
- (operator_loc.nil? == other.operator_loc.nil?) &&
10164
+ (binary_operator_loc.nil? == other.binary_operator_loc.nil?) &&
10165
10165
  (value === other.value) &&
10166
- (operator === other.operator)
10166
+ (binary_operator === other.binary_operator)
10167
10167
  end
10168
10168
  end
10169
10169
 
@@ -12093,16 +12093,16 @@ module Prism
12093
12093
  # target += value
12094
12094
  # ^^^^^^^^^^^^^^^
12095
12095
  class LocalVariableOperatorWriteNode < Node
12096
- # def initialize: (Location name_loc, Location operator_loc, Prism::node value, Symbol name, Symbol operator, Integer depth, Location location) -> void
12097
- def initialize(source, name_loc, operator_loc, value, name, operator, depth, location)
12096
+ # def initialize: (Location name_loc, Location binary_operator_loc, Prism::node value, Symbol name, Symbol binary_operator, Integer depth, Location location) -> void
12097
+ def initialize(source, name_loc, binary_operator_loc, value, name, binary_operator, depth, location)
12098
12098
  @source = source
12099
12099
  @newline = false
12100
12100
  @location = location
12101
12101
  @name_loc = name_loc
12102
- @operator_loc = operator_loc
12102
+ @binary_operator_loc = binary_operator_loc
12103
12103
  @value = value
12104
12104
  @name = name
12105
- @operator = operator
12105
+ @binary_operator = binary_operator
12106
12106
  @depth = depth
12107
12107
  end
12108
12108
 
@@ -12123,20 +12123,20 @@ module Prism
12123
12123
 
12124
12124
  # def comment_targets: () -> Array[Node | Location]
12125
12125
  def comment_targets
12126
- [name_loc, operator_loc, value] #: Array[Prism::node | Location]
12126
+ [name_loc, binary_operator_loc, value] #: Array[Prism::node | Location]
12127
12127
  end
12128
12128
 
12129
- # def copy: (?name_loc: Location, ?operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?operator: Symbol, ?depth: Integer, ?location: Location) -> LocalVariableOperatorWriteNode
12130
- def copy(name_loc: self.name_loc, operator_loc: self.operator_loc, value: self.value, name: self.name, operator: self.operator, depth: self.depth, location: self.location)
12131
- LocalVariableOperatorWriteNode.new(source, name_loc, operator_loc, value, name, operator, depth, location)
12129
+ # def copy: (?name_loc: Location, ?binary_operator_loc: Location, ?value: Prism::node, ?name: Symbol, ?binary_operator: Symbol, ?depth: Integer, ?location: Location) -> LocalVariableOperatorWriteNode
12130
+ def copy(name_loc: self.name_loc, binary_operator_loc: self.binary_operator_loc, value: self.value, name: self.name, binary_operator: self.binary_operator, depth: self.depth, location: self.location)
12131
+ LocalVariableOperatorWriteNode.new(source, name_loc, binary_operator_loc, value, name, binary_operator, depth, location)
12132
12132
  end
12133
12133
 
12134
12134
  # def deconstruct: () -> Array[nil | Node]
12135
12135
  alias deconstruct child_nodes
12136
12136
 
12137
- # def deconstruct_keys: (Array[Symbol] keys) -> { name_loc: Location, operator_loc: Location, value: Prism::node, name: Symbol, operator: Symbol, depth: Integer, location: Location }
12137
+ # def deconstruct_keys: (Array[Symbol] keys) -> { name_loc: Location, binary_operator_loc: Location, value: Prism::node, name: Symbol, binary_operator: Symbol, depth: Integer, location: Location }
12138
12138
  def deconstruct_keys(keys)
12139
- { name_loc: name_loc, operator_loc: operator_loc, value: value, name: name, operator: operator, depth: depth, location: location }
12139
+ { name_loc: name_loc, binary_operator_loc: binary_operator_loc, value: value, name: name, binary_operator: binary_operator, depth: depth, location: location }
12140
12140
  end
12141
12141
 
12142
12142
  # attr_reader name_loc: Location
@@ -12146,11 +12146,11 @@ module Prism
12146
12146
  @name_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
12147
12147
  end
12148
12148
 
12149
- # attr_reader operator_loc: Location
12150
- def operator_loc
12151
- location = @operator_loc
12149
+ # attr_reader binary_operator_loc: Location
12150
+ def binary_operator_loc
12151
+ location = @binary_operator_loc
12152
12152
  return location if location.is_a?(Location)
12153
- @operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
12153
+ @binary_operator_loc = Location.new(source, location >> 32, location & 0xFFFFFFFF)
12154
12154
  end
12155
12155
 
12156
12156
  # attr_reader value: Prism::node
@@ -12159,8 +12159,8 @@ module Prism
12159
12159
  # attr_reader name: Symbol
12160
12160
  attr_reader :name
12161
12161
 
12162
- # attr_reader operator: Symbol
12163
- attr_reader :operator
12162
+ # attr_reader binary_operator: Symbol
12163
+ attr_reader :binary_operator
12164
12164
 
12165
12165
  # attr_reader depth: Integer
12166
12166
  attr_reader :depth
@@ -12203,10 +12203,10 @@ module Prism
12203
12203
  def ===(other)
12204
12204
  other.is_a?(LocalVariableOperatorWriteNode) &&
12205
12205
  (name_loc.nil? == other.name_loc.nil?) &&
12206
- (operator_loc.nil? == other.operator_loc.nil?) &&
12206
+ (binary_operator_loc.nil? == other.binary_operator_loc.nil?) &&
12207
12207
  (value === other.value) &&
12208
12208
  (name === other.name) &&
12209
- (operator === other.operator) &&
12209
+ (binary_operator === other.binary_operator) &&
12210
12210
  (depth === other.depth)
12211
12211
  end
12212
12212
  end
@@ -14596,7 +14596,7 @@ module Prism
14596
14596
  # ^^^^^^^
14597
14597
  # end
14598
14598
  class ParametersNode < Node
14599
- # def initialize: (Array[RequiredParameterNode | MultiTargetNode] requireds, Array[OptionalParameterNode] optionals, RestParameterNode | ImplicitRestNode | nil rest, Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode] posts, Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode] keywords, KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil keyword_rest, BlockParameterNode? block, Location location) -> void
14599
+ # def initialize: (Array[RequiredParameterNode | MultiTargetNode] requireds, Array[OptionalParameterNode] optionals, RestParameterNode | ImplicitRestNode | nil rest, Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode] posts, Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode] keywords, KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil keyword_rest, BlockParameterNode? block, Location location) -> void
14600
14600
  def initialize(source, requireds, optionals, rest, posts, keywords, keyword_rest, block, location)
14601
14601
  @source = source
14602
14602
  @newline = false
@@ -14638,7 +14638,7 @@ module Prism
14638
14638
  [*requireds, *optionals, *rest, *posts, *keywords, *keyword_rest, *block] #: Array[Prism::node | Location]
14639
14639
  end
14640
14640
 
14641
- # def copy: (?requireds: Array[RequiredParameterNode | MultiTargetNode], ?optionals: Array[OptionalParameterNode], ?rest: RestParameterNode | ImplicitRestNode | nil, ?posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode], ?keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], ?keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, ?block: BlockParameterNode?, ?location: Location) -> ParametersNode
14641
+ # def copy: (?requireds: Array[RequiredParameterNode | MultiTargetNode], ?optionals: Array[OptionalParameterNode], ?rest: RestParameterNode | ImplicitRestNode | nil, ?posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode], ?keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], ?keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, ?block: BlockParameterNode?, ?location: Location) -> ParametersNode
14642
14642
  def copy(requireds: self.requireds, optionals: self.optionals, rest: self.rest, posts: self.posts, keywords: self.keywords, keyword_rest: self.keyword_rest, block: self.block, location: self.location)
14643
14643
  ParametersNode.new(source, requireds, optionals, rest, posts, keywords, keyword_rest, block, location)
14644
14644
  end
@@ -14646,7 +14646,7 @@ module Prism
14646
14646
  # def deconstruct: () -> Array[nil | Node]
14647
14647
  alias deconstruct child_nodes
14648
14648
 
14649
- # def deconstruct_keys: (Array[Symbol] keys) -> { requireds: Array[RequiredParameterNode | MultiTargetNode], optionals: Array[OptionalParameterNode], rest: RestParameterNode | ImplicitRestNode | nil, posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode], keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, block: BlockParameterNode?, location: Location }
14649
+ # def deconstruct_keys: (Array[Symbol] keys) -> { requireds: Array[RequiredParameterNode | MultiTargetNode], optionals: Array[OptionalParameterNode], rest: RestParameterNode | ImplicitRestNode | nil, posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode], keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode], keyword_rest: KeywordRestParameterNode | ForwardingParameterNode | NoKeywordsParameterNode | nil, block: BlockParameterNode?, location: Location }
14650
14650
  def deconstruct_keys(keys)
14651
14651
  { requireds: requireds, optionals: optionals, rest: rest, posts: posts, keywords: keywords, keyword_rest: keyword_rest, block: block, location: location }
14652
14652
  end
@@ -14660,7 +14660,7 @@ module Prism
14660
14660
  # attr_reader rest: RestParameterNode | ImplicitRestNode | nil
14661
14661
  attr_reader :rest
14662
14662
 
14663
- # attr_reader posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode]
14663
+ # attr_reader posts: Array[RequiredParameterNode | MultiTargetNode | KeywordRestParameterNode | NoKeywordsParameterNode | ForwardingParameterNode]
14664
14664
  attr_reader :posts
14665
14665
 
14666
14666
  # attr_reader keywords: Array[RequiredKeywordParameterNode | OptionalKeywordParameterNode]