prism 0.14.0 → 0.15.1

data/lib/prism/node.rb

@@ -1018,8 +1018,12 @@ module Prism
   #     $'
   #     ^^
   class BackReferenceReadNode < Node
-    # def initialize: (location: Location) -> void
-    def initialize(location)
+    # attr_reader name: Symbol
+    attr_reader :name
+
+    # def initialize: (name: Symbol, location: Location) -> void
+    def initialize(name, location)
+      @name = name
       @location = location
     end
 
@@ -1046,6 +1050,7 @@ module Prism
     # def copy: (**params) -> BackReferenceReadNode
     def copy(**params)
       BackReferenceReadNode.new(
+        params.fetch(:name) { name },
         params.fetch(:location) { location },
       )
     end
@@ -1055,11 +1060,12 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { location: location }
+      { name: name, location: location }
     end
 
     def inspect(inspector = NodeInspector.new)
       inspector << inspector.header(self)
+      inspector << "└── name: #{name.inspect}\n"
       inspector.to_str
     end
 
@@ -1913,15 +1919,6 @@ module Prism
     # attr_reader message_loc: Location?
     attr_reader :message_loc
 
-    # attr_reader opening_loc: Location?
-    attr_reader :opening_loc
-
-    # attr_reader arguments: ArgumentsNode?
-    attr_reader :arguments
-
-    # attr_reader closing_loc: Location?
-    attr_reader :closing_loc
-
     # attr_reader flags: Integer
     private attr_reader :flags
 
@@ -1937,14 +1934,11 @@ module Prism
     # attr_reader value: Node
     attr_reader :value
 
-    # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, flags: Integer, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location)
+    # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, flags: Integer, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator_loc, value, location)
       @receiver = receiver
       @call_operator_loc = call_operator_loc
       @message_loc = message_loc
-      @opening_loc = opening_loc
-      @arguments = arguments
-      @closing_loc = closing_loc
       @flags = flags
       @read_name = read_name
       @write_name = write_name
@@ -1960,21 +1954,20 @@ module Prism
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [receiver, arguments, value]
+      [receiver, value]
     end
 
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = []
       compact << receiver if receiver
-      compact << arguments if arguments
       compact << value
       compact
     end
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [*receiver, *call_operator_loc, *message_loc, *opening_loc, *arguments, *closing_loc, operator_loc, value]
+      [*receiver, *call_operator_loc, *message_loc, operator_loc, value]
     end
 
     # def copy: (**params) -> CallAndWriteNode
@@ -1983,9 +1976,6 @@ module Prism
         params.fetch(:receiver) { receiver },
         params.fetch(:call_operator_loc) { call_operator_loc },
         params.fetch(:message_loc) { message_loc },
-        params.fetch(:opening_loc) { opening_loc },
-        params.fetch(:arguments) { arguments },
-        params.fetch(:closing_loc) { closing_loc },
         params.fetch(:flags) { flags },
         params.fetch(:read_name) { read_name },
         params.fetch(:write_name) { write_name },
@@ -2000,7 +1990,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, flags: flags, read_name: read_name, write_name: write_name, operator_loc: operator_loc, value: value, location: location }
+      { receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, flags: flags, read_name: read_name, write_name: write_name, operator_loc: operator_loc, value: value, location: location }
     end
 
     # def call_operator: () -> String?
@@ -2013,16 +2003,6 @@ module Prism
       message_loc&.slice
     end
 
-    # def opening: () -> String?
-    def opening
-      opening_loc&.slice
-    end
-
-    # def closing: () -> String?
-    def closing
-      closing_loc&.slice
-    end
-
     # def safe_navigation?: () -> bool
     def safe_navigation?
       flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -2048,14 +2028,6 @@ module Prism
       end
       inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
       inspector << "├── message_loc: #{inspector.location(message_loc)}\n"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      if (arguments = self.arguments).nil?
-        inspector << "├── arguments: ∅\n"
-      else
-        inspector << "├── arguments:\n"
-        inspector << arguments.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
       flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
       inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector << "├── read_name: #{read_name.inspect}\n"
@@ -2307,15 +2279,6 @@ module Prism
     # attr_reader message_loc: Location?
     attr_reader :message_loc
 
-    # attr_reader opening_loc: Location?
-    attr_reader :opening_loc
-
-    # attr_reader arguments: ArgumentsNode?
-    attr_reader :arguments
-
-    # attr_reader closing_loc: Location?
-    attr_reader :closing_loc
-
     # attr_reader flags: Integer
     private attr_reader :flags
 
@@ -2334,14 +2297,11 @@ module Prism
     # attr_reader value: Node
     attr_reader :value
 
-    # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, flags: Integer, read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator, operator_loc, value, location)
+    # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, flags: Integer, read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator, operator_loc, value, location)
       @receiver = receiver
       @call_operator_loc = call_operator_loc
       @message_loc = message_loc
-      @opening_loc = opening_loc
-      @arguments = arguments
-      @closing_loc = closing_loc
       @flags = flags
       @read_name = read_name
       @write_name = write_name
@@ -2358,21 +2318,20 @@ module Prism
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [receiver, arguments, value]
+      [receiver, value]
     end
 
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = []
       compact << receiver if receiver
-      compact << arguments if arguments
       compact << value
       compact
     end
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [*receiver, *call_operator_loc, *message_loc, *opening_loc, *arguments, *closing_loc, operator_loc, value]
+      [*receiver, *call_operator_loc, *message_loc, operator_loc, value]
     end
 
     # def copy: (**params) -> CallOperatorWriteNode
@@ -2381,9 +2340,6 @@ module Prism
         params.fetch(:receiver) { receiver },
         params.fetch(:call_operator_loc) { call_operator_loc },
         params.fetch(:message_loc) { message_loc },
-        params.fetch(:opening_loc) { opening_loc },
-        params.fetch(:arguments) { arguments },
-        params.fetch(:closing_loc) { closing_loc },
         params.fetch(:flags) { flags },
         params.fetch(:read_name) { read_name },
         params.fetch(:write_name) { write_name },
@@ -2399,7 +2355,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, flags: flags, read_name: read_name, write_name: write_name, operator: operator, operator_loc: operator_loc, value: value, location: location }
+      { receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, flags: flags, read_name: read_name, write_name: write_name, operator: operator, operator_loc: operator_loc, value: value, location: location }
     end
 
     # def call_operator: () -> String?
@@ -2412,16 +2368,6 @@ module Prism
       message_loc&.slice
     end
 
-    # def opening: () -> String?
-    def opening
-      opening_loc&.slice
-    end
-
-    # def closing: () -> String?
-    def closing
-      closing_loc&.slice
-    end
-
     # def safe_navigation?: () -> bool
     def safe_navigation?
       flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -2442,14 +2388,6 @@ module Prism
       end
       inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
       inspector << "├── message_loc: #{inspector.location(message_loc)}\n"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      if (arguments = self.arguments).nil?
-        inspector << "├── arguments: ∅\n"
-      else
-        inspector << "├── arguments:\n"
-        inspector << arguments.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
       flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
       inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector << "├── read_name: #{read_name.inspect}\n"
@@ -2504,15 +2442,6 @@ module Prism
     # attr_reader message_loc: Location?
     attr_reader :message_loc
 
-    # attr_reader opening_loc: Location?
-    attr_reader :opening_loc
-
-    # attr_reader arguments: ArgumentsNode?
-    attr_reader :arguments
-
-    # attr_reader closing_loc: Location?
-    attr_reader :closing_loc
-
     # attr_reader flags: Integer
     private attr_reader :flags
 
@@ -2528,14 +2457,11 @@ module Prism
     # attr_reader value: Node
     attr_reader :value
 
-    # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, opening_loc: Location?, arguments: ArgumentsNode?, closing_loc: Location?, flags: Integer, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location) -> void
-    def initialize(receiver, call_operator_loc, message_loc, opening_loc, arguments, closing_loc, flags, read_name, write_name, operator_loc, value, location)
+    # def initialize: (receiver: Node?, call_operator_loc: Location?, message_loc: Location?, flags: Integer, read_name: Symbol, write_name: Symbol, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(receiver, call_operator_loc, message_loc, flags, read_name, write_name, operator_loc, value, location)
       @receiver = receiver
       @call_operator_loc = call_operator_loc
       @message_loc = message_loc
-      @opening_loc = opening_loc
-      @arguments = arguments
-      @closing_loc = closing_loc
       @flags = flags
       @read_name = read_name
       @write_name = write_name
@@ -2551,21 +2477,20 @@ module Prism
 
     # def child_nodes: () -> Array[nil | Node]
     def child_nodes
-      [receiver, arguments, value]
+      [receiver, value]
     end
 
     # def compact_child_nodes: () -> Array[Node]
     def compact_child_nodes
       compact = []
       compact << receiver if receiver
-      compact << arguments if arguments
       compact << value
       compact
     end
 
     # def comment_targets: () -> Array[Node | Location]
     def comment_targets
-      [*receiver, *call_operator_loc, *message_loc, *opening_loc, *arguments, *closing_loc, operator_loc, value]
+      [*receiver, *call_operator_loc, *message_loc, operator_loc, value]
     end
 
     # def copy: (**params) -> CallOrWriteNode
@@ -2574,9 +2499,6 @@ module Prism
         params.fetch(:receiver) { receiver },
         params.fetch(:call_operator_loc) { call_operator_loc },
         params.fetch(:message_loc) { message_loc },
-        params.fetch(:opening_loc) { opening_loc },
-        params.fetch(:arguments) { arguments },
-        params.fetch(:closing_loc) { closing_loc },
         params.fetch(:flags) { flags },
         params.fetch(:read_name) { read_name },
         params.fetch(:write_name) { write_name },
@@ -2591,7 +2513,7 @@ module Prism
 
     # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
     def deconstruct_keys(keys)
-      { receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, flags: flags, read_name: read_name, write_name: write_name, operator_loc: operator_loc, value: value, location: location }
+      { receiver: receiver, call_operator_loc: call_operator_loc, message_loc: message_loc, flags: flags, read_name: read_name, write_name: write_name, operator_loc: operator_loc, value: value, location: location }
     end
 
     # def call_operator: () -> String?
@@ -2604,16 +2526,6 @@ module Prism
       message_loc&.slice
     end
 
-    # def opening: () -> String?
-    def opening
-      opening_loc&.slice
-    end
-
-    # def closing: () -> String?
-    def closing
-      closing_loc&.slice
-    end
-
     # def safe_navigation?: () -> bool
     def safe_navigation?
       flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
@@ -2639,14 +2551,6 @@ module Prism
       end
       inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
       inspector << "├── message_loc: #{inspector.location(message_loc)}\n"
-      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
-      if (arguments = self.arguments).nil?
-        inspector << "├── arguments: ∅\n"
-      else
-        inspector << "├── arguments:\n"
-        inspector << arguments.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
-      end
-      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
       flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
       inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
       inspector << "├── read_name: #{read_name.inspect}\n"
@@ -7826,6 +7730,562 @@ module Prism
     end
   end
 
+  # Represents the use of the `&&=` operator on a call to the `[]` method.
+  #
+  #     foo.bar[baz] &&= value
+  #     ^^^^^^^^^^^^^^^^^^^^^^
+  class IndexAndWriteNode < Node
+    # attr_reader receiver: Node?
+    attr_reader :receiver
+
+    # attr_reader call_operator_loc: Location?
+    attr_reader :call_operator_loc
+
+    # attr_reader opening_loc: Location
+    attr_reader :opening_loc
+
+    # attr_reader arguments: ArgumentsNode?
+    attr_reader :arguments
+
+    # attr_reader closing_loc: Location
+    attr_reader :closing_loc
+
+    # attr_reader block: Node?
+    attr_reader :block
+
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
+    # attr_reader operator_loc: Location
+    attr_reader :operator_loc
+
+    # attr_reader value: Node
+    attr_reader :value
+
+    # def initialize: (receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, flags: Integer, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator_loc, value, location)
+      @receiver = receiver
+      @call_operator_loc = call_operator_loc
+      @opening_loc = opening_loc
+      @arguments = arguments
+      @closing_loc = closing_loc
+      @block = block
+      @flags = flags
+      @operator_loc = operator_loc
+      @value = value
+      @location = location
+    end
+
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_index_and_write_node(self)
+    end
+
+    # def child_nodes: () -> Array[nil | Node]
+    def child_nodes
+      [receiver, arguments, block, value]
+    end
+
+    # def compact_child_nodes: () -> Array[Node]
+    def compact_child_nodes
+      compact = []
+      compact << receiver if receiver
+      compact << arguments if arguments
+      compact << block if block
+      compact << value
+      compact
+    end
+
+    # def comment_targets: () -> Array[Node | Location]
+    def comment_targets
+      [*receiver, *call_operator_loc, opening_loc, *arguments, closing_loc, *block, operator_loc, value]
+    end
+
+    # def copy: (**params) -> IndexAndWriteNode
+    def copy(**params)
+      IndexAndWriteNode.new(
+        params.fetch(:receiver) { receiver },
+        params.fetch(:call_operator_loc) { call_operator_loc },
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:arguments) { arguments },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:block) { block },
+        params.fetch(:flags) { flags },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:location) { location },
+      )
+    end
+
+    # def deconstruct: () -> Array[nil | Node]
+    alias deconstruct child_nodes
+
+    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+    def deconstruct_keys(keys)
+      { receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, flags: flags, operator_loc: operator_loc, value: value, location: location }
+    end
+
+    # def call_operator: () -> String?
+    def call_operator
+      call_operator_loc&.slice
+    end
+
+    # def opening: () -> String
+    def opening
+      opening_loc.slice
+    end
+
+    # def closing: () -> String
+    def closing
+      closing_loc.slice
+    end
+
+    # def safe_navigation?: () -> bool
+    def safe_navigation?
+      flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
+    end
+
+    # def variable_call?: () -> bool
+    def variable_call?
+      flags.anybits?(CallNodeFlags::VARIABLE_CALL)
+    end
+
+    # def operator: () -> String
+    def operator
+      operator_loc.slice
+    end
+
+    def inspect(inspector = NodeInspector.new)
+      inspector << inspector.header(self)
+      if (receiver = self.receiver).nil?
+        inspector << "├── receiver: ∅\n"
+      else
+        inspector << "├── receiver:\n"
+        inspector << receiver.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
+      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
+      if (arguments = self.arguments).nil?
+        inspector << "├── arguments: ∅\n"
+      else
+        inspector << "├── arguments:\n"
+        inspector << arguments.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
+      if (block = self.block).nil?
+        inspector << "├── block: ∅\n"
+      else
+        inspector << "├── block:\n"
+        inspector << block.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
+      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
+      inspector << "└── value:\n"
+      inspector << inspector.child_node(value, "    ")
+      inspector.to_str
+    end
+
+    # Sometimes you want to check an instance of a node against a list of
+    # classes to see what kind of behavior to perform. Usually this is done by
+    # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+    # case statement and doing `case node; when cls1; when cls2; end`. Both of
+    # these approaches are relatively slow because of the constant lookups,
+    # method calls, and/or array allocations.
+    #
+    # Instead, you can call #type, which will return to you a symbol that you
+    # can use for comparison. This is faster than the other approaches because
+    # it uses a single integer comparison, but also because if you're on CRuby
+    # you can take advantage of the fact that case statements with all symbol
+    # keys will use a jump table.
+    #
+    # def type: () -> Symbol
+    def type
+      :index_and_write_node
+    end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :index_and_write_node
+    end
+  end
+
+  # Represents the use of an assignment operator on a call to `[]`.
+  #
+  #     foo.bar[baz] += value
+  #     ^^^^^^^^^^^^^^^^^^^^^
+  class IndexOperatorWriteNode < Node
+    # attr_reader receiver: Node?
+    attr_reader :receiver
+
+    # attr_reader call_operator_loc: Location?
+    attr_reader :call_operator_loc
+
+    # attr_reader opening_loc: Location
+    attr_reader :opening_loc
+
+    # attr_reader arguments: ArgumentsNode?
+    attr_reader :arguments
+
+    # attr_reader closing_loc: Location
+    attr_reader :closing_loc
+
+    # attr_reader block: Node?
+    attr_reader :block
+
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
+    # attr_reader operator: Symbol
+    attr_reader :operator
+
+    # attr_reader operator_loc: Location
+    attr_reader :operator_loc
+
+    # attr_reader value: Node
+    attr_reader :value
+
+    # def initialize: (receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, flags: Integer, operator: Symbol, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator, operator_loc, value, location)
+      @receiver = receiver
+      @call_operator_loc = call_operator_loc
+      @opening_loc = opening_loc
+      @arguments = arguments
+      @closing_loc = closing_loc
+      @block = block
+      @flags = flags
+      @operator = operator
+      @operator_loc = operator_loc
+      @value = value
+      @location = location
+    end
+
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_index_operator_write_node(self)
+    end
+
+    # def child_nodes: () -> Array[nil | Node]
+    def child_nodes
+      [receiver, arguments, block, value]
+    end
+
+    # def compact_child_nodes: () -> Array[Node]
+    def compact_child_nodes
+      compact = []
+      compact << receiver if receiver
+      compact << arguments if arguments
+      compact << block if block
+      compact << value
+      compact
+    end
+
+    # def comment_targets: () -> Array[Node | Location]
+    def comment_targets
+      [*receiver, *call_operator_loc, opening_loc, *arguments, closing_loc, *block, operator_loc, value]
+    end
+
+    # def copy: (**params) -> IndexOperatorWriteNode
+    def copy(**params)
+      IndexOperatorWriteNode.new(
+        params.fetch(:receiver) { receiver },
+        params.fetch(:call_operator_loc) { call_operator_loc },
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:arguments) { arguments },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:block) { block },
+        params.fetch(:flags) { flags },
+        params.fetch(:operator) { operator },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:location) { location },
+      )
+    end
+
+    # def deconstruct: () -> Array[nil | Node]
+    alias deconstruct child_nodes
+
+    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+    def deconstruct_keys(keys)
+      { receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, flags: flags, operator: operator, operator_loc: operator_loc, value: value, location: location }
+    end
+
+    # def call_operator: () -> String?
+    def call_operator
+      call_operator_loc&.slice
+    end
+
+    # def opening: () -> String
+    def opening
+      opening_loc.slice
+    end
+
+    # def closing: () -> String
+    def closing
+      closing_loc.slice
+    end
+
+    # def safe_navigation?: () -> bool
+    def safe_navigation?
+      flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
+    end
+
+    # def variable_call?: () -> bool
+    def variable_call?
+      flags.anybits?(CallNodeFlags::VARIABLE_CALL)
+    end
+
+    def inspect(inspector = NodeInspector.new)
+      inspector << inspector.header(self)
+      if (receiver = self.receiver).nil?
+        inspector << "├── receiver: ∅\n"
+      else
+        inspector << "├── receiver:\n"
+        inspector << receiver.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
+      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
+      if (arguments = self.arguments).nil?
+        inspector << "├── arguments: ∅\n"
+      else
+        inspector << "├── arguments:\n"
+        inspector << arguments.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
+      if (block = self.block).nil?
+        inspector << "├── block: ∅\n"
+      else
+        inspector << "├── block:\n"
+        inspector << block.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
+      inspector << "├── operator: #{operator.inspect}\n"
+      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
+      inspector << "└── value:\n"
+      inspector << inspector.child_node(value, "    ")
+      inspector.to_str
+    end
+
+    # Sometimes you want to check an instance of a node against a list of
+    # classes to see what kind of behavior to perform. Usually this is done by
+    # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+    # case statement and doing `case node; when cls1; when cls2; end`. Both of
+    # these approaches are relatively slow because of the constant lookups,
+    # method calls, and/or array allocations.
+    #
+    # Instead, you can call #type, which will return to you a symbol that you
+    # can use for comparison. This is faster than the other approaches because
+    # it uses a single integer comparison, but also because if you're on CRuby
+    # you can take advantage of the fact that case statements with all symbol
+    # keys will use a jump table.
+    #
+    # def type: () -> Symbol
+    def type
+      :index_operator_write_node
+    end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :index_operator_write_node
+    end
+  end
+
+  # Represents the use of the `||=` operator on a call to `[]`.
+  #
+  #     foo.bar[baz] ||= value
+  #     ^^^^^^^^^^^^^^^^^^^^^^
+  class IndexOrWriteNode < Node
+    # attr_reader receiver: Node?
+    attr_reader :receiver
+
+    # attr_reader call_operator_loc: Location?
+    attr_reader :call_operator_loc
+
+    # attr_reader opening_loc: Location
+    attr_reader :opening_loc
+
+    # attr_reader arguments: ArgumentsNode?
+    attr_reader :arguments
+
+    # attr_reader closing_loc: Location
+    attr_reader :closing_loc
+
+    # attr_reader block: Node?
+    attr_reader :block
+
+    # attr_reader flags: Integer
+    private attr_reader :flags
+
+    # attr_reader operator_loc: Location
+    attr_reader :operator_loc
+
+    # attr_reader value: Node
+    attr_reader :value
+
+    # def initialize: (receiver: Node?, call_operator_loc: Location?, opening_loc: Location, arguments: ArgumentsNode?, closing_loc: Location, block: Node?, flags: Integer, operator_loc: Location, value: Node, location: Location) -> void
+    def initialize(receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, flags, operator_loc, value, location)
+      @receiver = receiver
+      @call_operator_loc = call_operator_loc
+      @opening_loc = opening_loc
+      @arguments = arguments
+      @closing_loc = closing_loc
+      @block = block
+      @flags = flags
+      @operator_loc = operator_loc
+      @value = value
+      @location = location
+    end
+
+    # def accept: (visitor: Visitor) -> void
+    def accept(visitor)
+      visitor.visit_index_or_write_node(self)
+    end
+
+    # def child_nodes: () -> Array[nil | Node]
+    def child_nodes
+      [receiver, arguments, block, value]
+    end
+
+    # def compact_child_nodes: () -> Array[Node]
+    def compact_child_nodes
+      compact = []
+      compact << receiver if receiver
+      compact << arguments if arguments
+      compact << block if block
+      compact << value
+      compact
+    end
+
+    # def comment_targets: () -> Array[Node | Location]
+    def comment_targets
+      [*receiver, *call_operator_loc, opening_loc, *arguments, closing_loc, *block, operator_loc, value]
+    end
+
+    # def copy: (**params) -> IndexOrWriteNode
+    def copy(**params)
+      IndexOrWriteNode.new(
+        params.fetch(:receiver) { receiver },
+        params.fetch(:call_operator_loc) { call_operator_loc },
+        params.fetch(:opening_loc) { opening_loc },
+        params.fetch(:arguments) { arguments },
+        params.fetch(:closing_loc) { closing_loc },
+        params.fetch(:block) { block },
+        params.fetch(:flags) { flags },
+        params.fetch(:operator_loc) { operator_loc },
+        params.fetch(:value) { value },
+        params.fetch(:location) { location },
+      )
+    end
+
+    # def deconstruct: () -> Array[nil | Node]
+    alias deconstruct child_nodes
+
+    # def deconstruct_keys: (keys: Array[Symbol]) -> Hash[Symbol, nil | Node | Array[Node] | String | Token | Array[Token] | Location]
+    def deconstruct_keys(keys)
+      { receiver: receiver, call_operator_loc: call_operator_loc, opening_loc: opening_loc, arguments: arguments, closing_loc: closing_loc, block: block, flags: flags, operator_loc: operator_loc, value: value, location: location }
+    end
+
+    # def call_operator: () -> String?
+    def call_operator
+      call_operator_loc&.slice
+    end
+
+    # def opening: () -> String
+    def opening
+      opening_loc.slice
+    end
+
+    # def closing: () -> String
+    def closing
+      closing_loc.slice
+    end
+
+    # def safe_navigation?: () -> bool
+    def safe_navigation?
+      flags.anybits?(CallNodeFlags::SAFE_NAVIGATION)
+    end
+
+    # def variable_call?: () -> bool
+    def variable_call?
+      flags.anybits?(CallNodeFlags::VARIABLE_CALL)
+    end
+
+    # def operator: () -> String
+    def operator
+      operator_loc.slice
+    end
+
+    def inspect(inspector = NodeInspector.new)
+      inspector << inspector.header(self)
+      if (receiver = self.receiver).nil?
+        inspector << "├── receiver: ∅\n"
+      else
+        inspector << "├── receiver:\n"
+        inspector << receiver.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      inspector << "├── call_operator_loc: #{inspector.location(call_operator_loc)}\n"
+      inspector << "├── opening_loc: #{inspector.location(opening_loc)}\n"
+      if (arguments = self.arguments).nil?
+        inspector << "├── arguments: ∅\n"
+      else
+        inspector << "├── arguments:\n"
+        inspector << arguments.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      inspector << "├── closing_loc: #{inspector.location(closing_loc)}\n"
+      if (block = self.block).nil?
+        inspector << "├── block: ∅\n"
+      else
+        inspector << "├── block:\n"
+        inspector << block.inspect(inspector.child_inspector("│   ")).delete_prefix(inspector.prefix)
+      end
+      flags = [("safe_navigation" if safe_navigation?), ("variable_call" if variable_call?)].compact
+      inspector << "├── flags: #{flags.empty? ? "∅" : flags.join(", ")}\n"
+      inspector << "├── operator_loc: #{inspector.location(operator_loc)}\n"
+      inspector << "└── value:\n"
+      inspector << inspector.child_node(value, "    ")
+      inspector.to_str
+    end
+
+    # Sometimes you want to check an instance of a node against a list of
+    # classes to see what kind of behavior to perform. Usually this is done by
+    # calling `[cls1, cls2].include?(node.class)` or putting the node into a
+    # case statement and doing `case node; when cls1; when cls2; end`. Both of
+    # these approaches are relatively slow because of the constant lookups,
+    # method calls, and/or array allocations.
+    #
+    # Instead, you can call #type, which will return to you a symbol that you
+    # can use for comparison. This is faster than the other approaches because
+    # it uses a single integer comparison, but also because if you're on CRuby
+    # you can take advantage of the fact that case statements with all symbol
+    # keys will use a jump table.
+    #
+    # def type: () -> Symbol
+    def type
+      :index_or_write_node
+    end
+
+    # Similar to #type, this method returns a symbol that you can use for
+    # splitting on the type of the node without having to do a long === chain.
+    # Note that like #type, it will still be slower than using == for a single
+    # class, but should be faster in a case statement or an array comparison.
+    #
+    # def self.type: () -> Symbol
+    def self.type
+      :index_or_write_node
+    end
+  end
+
   # Represents the use of the `&&=` operator for assignment to an instance variable.
   #
   #     @target &&= value