prism 0.28.0 → 0.29.0

data/lib/prism/translation/ripper.rb

@@ -1181,8 +1181,8 @@ module Prism
         bounds(node.location)
         target = on_field(receiver, call_operator, message)
 
-        bounds(node.operator_loc)
-        operator = on_op("#{node.operator}=")
+        bounds(node.binary_operator_loc)
+        operator = on_op("#{node.binary_operator}=")
         value = visit_write_value(node.value)
 
         bounds(node.location)
@@ -1339,8 +1339,8 @@ module Prism
         bounds(node.name_loc)
         target = on_var_field(on_cvar(node.name.to_s))
 
-        bounds(node.operator_loc)
-        operator = on_op("#{node.operator}=")
+        bounds(node.binary_operator_loc)
+        operator = on_op("#{node.binary_operator}=")
         value = visit_write_value(node.value)
 
         bounds(node.location)
@@ -1409,8 +1409,8 @@ module Prism
         bounds(node.name_loc)
         target = on_var_field(on_const(node.name.to_s))
 
-        bounds(node.operator_loc)
-        operator = on_op("#{node.operator}=")
+        bounds(node.binary_operator_loc)
+        operator = on_op("#{node.binary_operator}=")
         value = visit_write_value(node.value)
 
         bounds(node.location)
@@ -1510,8 +1510,8 @@ module Prism
         target = visit_constant_path_write_node_target(node.target)
         value = visit(node.value)
 
-        bounds(node.operator_loc)
-        operator = on_op("#{node.operator}=")
+        bounds(node.binary_operator_loc)
+        operator = on_op("#{node.binary_operator}=")
         value = visit_write_value(node.value)
 
         bounds(node.location)
@@ -1802,8 +1802,8 @@ module Prism
         bounds(node.name_loc)
         target = on_var_field(on_gvar(node.name.to_s))
 
-        bounds(node.operator_loc)
-        operator = on_op("#{node.operator}=")
+        bounds(node.binary_operator_loc)
+        operator = on_op("#{node.binary_operator}=")
         value = visit_write_value(node.value)
 
         bounds(node.location)
@@ -1983,8 +1983,8 @@ module Prism
         bounds(node.location)
         target = on_aref_field(receiver, arguments)
 
-        bounds(node.operator_loc)
-        operator = on_op("#{node.operator}=")
+        bounds(node.binary_operator_loc)
+        operator = on_op("#{node.binary_operator}=")
         value = visit_write_value(node.value)
 
         bounds(node.location)
@@ -2059,8 +2059,8 @@ module Prism
         bounds(node.name_loc)
         target = on_var_field(on_ivar(node.name.to_s))
 
-        bounds(node.operator_loc)
-        operator = on_op("#{node.operator}=")
+        bounds(node.binary_operator_loc)
+        operator = on_op("#{node.binary_operator}=")
         value = visit_write_value(node.value)
 
         bounds(node.location)
@@ -2337,8 +2337,8 @@ module Prism
         bounds(node.name_loc)
         target = on_var_field(on_ident(node.name_loc.slice))
 
-        bounds(node.operator_loc)
-        operator = on_op("#{node.operator}=")
+        bounds(node.binary_operator_loc)
+        operator = on_op("#{node.binary_operator}=")
         value = visit_write_value(node.value)
 
         bounds(node.location)

data/lib/prism/translation/ruby_parser.rb

@@ -271,9 +271,9 @@ module Prism
         # ^^^^^^^^^^^^^^^
         def visit_call_operator_write_node(node)
           if op_asgn?(node)
-            s(node, op_asgn_type(node, :op_asgn), visit(node.receiver), visit_write_value(node.value), node.read_name, node.operator)
+            s(node, op_asgn_type(node, :op_asgn), visit(node.receiver), visit_write_value(node.value), node.read_name, node.binary_operator)
           else
-            s(node, op_asgn_type(node, :op_asgn2), visit(node.receiver), node.write_name, node.operator, visit_write_value(node.value))
+            s(node, op_asgn_type(node, :op_asgn2), visit(node.receiver), node.write_name, node.binary_operator, visit_write_value(node.value))
           end
         end
 
@@ -372,7 +372,7 @@ module Prism
         # @@foo += bar
         # ^^^^^^^^^^^^
         def visit_class_variable_operator_write_node(node)
-          s(node, class_variable_write_type, node.name, s(node, :call, s(node, :cvar, node.name), node.operator, visit_write_value(node.value)))
+          s(node, class_variable_write_type, node.name, s(node, :call, s(node, :cvar, node.name), node.binary_operator, visit_write_value(node.value)))
         end
 
         # @@foo &&= bar
@@ -417,7 +417,7 @@ module Prism
         # Foo += bar
         # ^^^^^^^^^^^
         def visit_constant_operator_write_node(node)
-          s(node, :cdecl, node.name, s(node, :call, s(node, :const, node.name), node.operator, visit_write_value(node.value)))
+          s(node, :cdecl, node.name, s(node, :call, s(node, :const, node.name), node.binary_operator, visit_write_value(node.value)))
         end
 
         # Foo &&= bar
@@ -460,7 +460,7 @@ module Prism
         # Foo::Bar += baz
         # ^^^^^^^^^^^^^^^
         def visit_constant_path_operator_write_node(node)
-          s(node, :op_asgn, visit(node.target), node.operator, visit_write_value(node.value))
+          s(node, :op_asgn, visit(node.target), node.binary_operator, visit_write_value(node.value))
         end
 
         # Foo::Bar &&= baz
@@ -627,7 +627,7 @@ module Prism
         # $foo += bar
         # ^^^^^^^^^^^
         def visit_global_variable_operator_write_node(node)
-          s(node, :gasgn, node.name, s(node, :call, s(node, :gvar, node.name), node.operator, visit(node.value)))
+          s(node, :gasgn, node.name, s(node, :call, s(node, :gvar, node.name), node.binary_operator, visit(node.value)))
         end
 
         # $foo &&= bar
@@ -719,7 +719,7 @@ module Prism
             arglist << visit(node.block) if !node.block.nil?
           end
 
-          s(node, :op_asgn1, visit(node.receiver), arglist, node.operator, visit_write_value(node.value))
+          s(node, :op_asgn1, visit(node.receiver), arglist, node.binary_operator, visit_write_value(node.value))
         end
 
         # foo[bar] &&= baz
@@ -775,7 +775,7 @@ module Prism
         # @foo += bar
         # ^^^^^^^^^^^
         def visit_instance_variable_operator_write_node(node)
-          s(node, :iasgn, node.name, s(node, :call, s(node, :ivar, node.name), node.operator, visit_write_value(node.value)))
+          s(node, :iasgn, node.name, s(node, :call, s(node, :ivar, node.name), node.binary_operator, visit_write_value(node.value)))
         end
 
         # @foo &&= bar
@@ -960,7 +960,7 @@ module Prism
         # foo += bar
         # ^^^^^^^^^^
         def visit_local_variable_operator_write_node(node)
-          s(node, :lasgn, node.name, s(node, :call, s(node, :lvar, node.name), node.operator, visit_write_value(node.value)))
+          s(node, :lasgn, node.name, s(node, :call, s(node, :lvar, node.name), node.binary_operator, visit_write_value(node.value)))
         end
 
         # foo &&= bar

data/prism.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |spec|
   spec.name = "prism"
-  spec.version = "0.28.0"
+  spec.version = "0.29.0"
   spec.authors = ["Shopify"]
   spec.email = ["ruby@shopify.com"]
 
@@ -121,6 +121,7 @@ Gem::Specification.new do |spec|
     "sig/prism/dot_visitor.rbs",
     "sig/prism/dsl.rbs",
     "sig/prism/inspect_visitor.rbs",
+    "sig/prism/lex_compat.rbs",
     "sig/prism/mutation_compiler.rbs",
     "sig/prism/node_ext.rbs",
     "sig/prism/node.rbs",

data/rbi/prism/node.rbi

@@ -1199,16 +1199,16 @@ class Prism::CallOperatorWriteNode < Prism::Node
   def write_name; end
 
   sig { returns(Symbol) }
-  def operator; end
+  def binary_operator; end
 
   sig { returns(Prism::Location) }
-  def operator_loc; end
+  def binary_operator_loc; end
 
   sig { returns(Prism::Node) }
   def value; end
 
-  sig { params(source: Prism::Source, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void }
-  def initialize(source, flags, receiver, call_operator_loc, message_loc, read_name, write_name, operator, operator_loc, value, location); end
+  sig { params(source: Prism::Source, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), read_name: Symbol, write_name: Symbol, binary_operator: Symbol, binary_operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void }
+  def initialize(source, flags, receiver, call_operator_loc, message_loc, read_name, write_name, binary_operator, binary_operator_loc, value, location); end
 
   sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
   def accept(visitor); end
@@ -1225,8 +1225,8 @@ class Prism::CallOperatorWriteNode < Prism::Node
   sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
   def comment_targets; end
 
-  sig { params(flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), read_name: Symbol, write_name: Symbol, operator: Symbol, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::CallOperatorWriteNode) }
-  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); end
+  sig { params(flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), message_loc: T.nilable(Prism::Location), read_name: Symbol, write_name: Symbol, binary_operator: Symbol, binary_operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::CallOperatorWriteNode) }
+  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); end
 
   sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
   def deconstruct_keys(keys); end
@@ -1736,16 +1736,16 @@ class Prism::ClassVariableOperatorWriteNode < Prism::Node
   def name_loc; end
 
   sig { returns(Prism::Location) }
-  def operator_loc; end
+  def binary_operator_loc; end
 
   sig { returns(Prism::Node) }
   def value; end
 
   sig { returns(Symbol) }
-  def operator; end
+  def binary_operator; end
 
-  sig { params(source: Prism::Source, name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, operator: Symbol, location: Prism::Location).void }
-  def initialize(source, name, name_loc, operator_loc, value, operator, location); end
+  sig { params(source: Prism::Source, name: Symbol, name_loc: Prism::Location, binary_operator_loc: Prism::Location, value: Prism::Node, binary_operator: Symbol, location: Prism::Location).void }
+  def initialize(source, name, name_loc, binary_operator_loc, value, binary_operator, location); end
 
   sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
   def accept(visitor); end
@@ -1762,8 +1762,8 @@ class Prism::ClassVariableOperatorWriteNode < Prism::Node
   sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
   def comment_targets; end
 
-  sig { params(name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, operator: Symbol, location: Prism::Location).returns(Prism::ClassVariableOperatorWriteNode) }
-  def copy(name: self.name, name_loc: self.name_loc, operator_loc: self.operator_loc, value: self.value, operator: self.operator, location: self.location); end
+  sig { params(name: Symbol, name_loc: Prism::Location, binary_operator_loc: Prism::Location, value: Prism::Node, binary_operator: Symbol, location: Prism::Location).returns(Prism::ClassVariableOperatorWriteNode) }
+  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); end
 
   sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
   def deconstruct_keys(keys); end
@@ -2036,16 +2036,16 @@ class Prism::ConstantOperatorWriteNode < Prism::Node
   def name_loc; end
 
   sig { returns(Prism::Location) }
-  def operator_loc; end
+  def binary_operator_loc; end
 
   sig { returns(Prism::Node) }
   def value; end
 
   sig { returns(Symbol) }
-  def operator; end
+  def binary_operator; end
 
-  sig { params(source: Prism::Source, name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, operator: Symbol, location: Prism::Location).void }
-  def initialize(source, name, name_loc, operator_loc, value, operator, location); end
+  sig { params(source: Prism::Source, name: Symbol, name_loc: Prism::Location, binary_operator_loc: Prism::Location, value: Prism::Node, binary_operator: Symbol, location: Prism::Location).void }
+  def initialize(source, name, name_loc, binary_operator_loc, value, binary_operator, location); end
 
   sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
   def accept(visitor); end
@@ -2062,8 +2062,8 @@ class Prism::ConstantOperatorWriteNode < Prism::Node
   sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
   def comment_targets; end
 
-  sig { params(name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, operator: Symbol, location: Prism::Location).returns(Prism::ConstantOperatorWriteNode) }
-  def copy(name: self.name, name_loc: self.name_loc, operator_loc: self.operator_loc, value: self.value, operator: self.operator, location: self.location); end
+  sig { params(name: Symbol, name_loc: Prism::Location, binary_operator_loc: Prism::Location, value: Prism::Node, binary_operator: Symbol, location: Prism::Location).returns(Prism::ConstantOperatorWriteNode) }
+  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); end
 
   sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
   def deconstruct_keys(keys); end
@@ -2246,16 +2246,16 @@ class Prism::ConstantPathOperatorWriteNode < Prism::Node
   def target; end
 
   sig { returns(Prism::Location) }
-  def operator_loc; end
+  def binary_operator_loc; end
 
   sig { returns(Prism::Node) }
   def value; end
 
   sig { returns(Symbol) }
-  def operator; end
+  def binary_operator; end
 
-  sig { params(source: Prism::Source, target: Prism::ConstantPathNode, operator_loc: Prism::Location, value: Prism::Node, operator: Symbol, location: Prism::Location).void }
-  def initialize(source, target, operator_loc, value, operator, location); end
+  sig { params(source: Prism::Source, target: Prism::ConstantPathNode, binary_operator_loc: Prism::Location, value: Prism::Node, binary_operator: Symbol, location: Prism::Location).void }
+  def initialize(source, target, binary_operator_loc, value, binary_operator, location); end
 
   sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
   def accept(visitor); end
@@ -2272,8 +2272,8 @@ class Prism::ConstantPathOperatorWriteNode < Prism::Node
   sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
   def comment_targets; end
 
-  sig { params(target: Prism::ConstantPathNode, operator_loc: Prism::Location, value: Prism::Node, operator: Symbol, location: Prism::Location).returns(Prism::ConstantPathOperatorWriteNode) }
-  def copy(target: self.target, operator_loc: self.operator_loc, value: self.value, operator: self.operator, location: self.location); end
+  sig { params(target: Prism::ConstantPathNode, binary_operator_loc: Prism::Location, value: Prism::Node, binary_operator: Symbol, location: Prism::Location).returns(Prism::ConstantPathOperatorWriteNode) }
+  def copy(target: self.target, binary_operator_loc: self.binary_operator_loc, value: self.value, binary_operator: self.binary_operator, location: self.location); end
 
   sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
   def deconstruct_keys(keys); end
@@ -3424,16 +3424,16 @@ class Prism::GlobalVariableOperatorWriteNode < Prism::Node
   def name_loc; end
 
   sig { returns(Prism::Location) }
-  def operator_loc; end
+  def binary_operator_loc; end
 
   sig { returns(Prism::Node) }
   def value; end
 
   sig { returns(Symbol) }
-  def operator; end
+  def binary_operator; end
 
-  sig { params(source: Prism::Source, name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, operator: Symbol, location: Prism::Location).void }
-  def initialize(source, name, name_loc, operator_loc, value, operator, location); end
+  sig { params(source: Prism::Source, name: Symbol, name_loc: Prism::Location, binary_operator_loc: Prism::Location, value: Prism::Node, binary_operator: Symbol, location: Prism::Location).void }
+  def initialize(source, name, name_loc, binary_operator_loc, value, binary_operator, location); end
 
   sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
   def accept(visitor); end
@@ -3450,8 +3450,8 @@ class Prism::GlobalVariableOperatorWriteNode < Prism::Node
   sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
   def comment_targets; end
 
-  sig { params(name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, operator: Symbol, location: Prism::Location).returns(Prism::GlobalVariableOperatorWriteNode) }
-  def copy(name: self.name, name_loc: self.name_loc, operator_loc: self.operator_loc, value: self.value, operator: self.operator, location: self.location); end
+  sig { params(name: Symbol, name_loc: Prism::Location, binary_operator_loc: Prism::Location, value: Prism::Node, binary_operator: Symbol, location: Prism::Location).returns(Prism::GlobalVariableOperatorWriteNode) }
+  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); end
 
   sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
   def deconstruct_keys(keys); end
@@ -4159,16 +4159,16 @@ class Prism::IndexOperatorWriteNode < Prism::Node
   def block; end
 
   sig { returns(Symbol) }
-  def operator; end
+  def binary_operator; end
 
   sig { returns(Prism::Location) }
-  def operator_loc; end
+  def binary_operator_loc; end
 
   sig { returns(Prism::Node) }
   def value; end
 
-  sig { params(source: Prism::Source, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), operator: Symbol, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void }
-  def initialize(source, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, operator, operator_loc, value, location); end
+  sig { params(source: Prism::Source, flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), binary_operator: Symbol, binary_operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).void }
+  def initialize(source, flags, receiver, call_operator_loc, opening_loc, arguments, closing_loc, block, binary_operator, binary_operator_loc, value, location); end
 
   sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
   def accept(visitor); end
@@ -4185,8 +4185,8 @@ class Prism::IndexOperatorWriteNode < Prism::Node
   sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
   def comment_targets; end
 
-  sig { params(flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), operator: Symbol, operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::IndexOperatorWriteNode) }
-  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); end
+  sig { params(flags: Integer, receiver: T.nilable(Prism::Node), call_operator_loc: T.nilable(Prism::Location), opening_loc: Prism::Location, arguments: T.nilable(Prism::ArgumentsNode), closing_loc: Prism::Location, block: T.nilable(Prism::Node), binary_operator: Symbol, binary_operator_loc: Prism::Location, value: Prism::Node, location: Prism::Location).returns(Prism::IndexOperatorWriteNode) }
+  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); end
 
   sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
   def deconstruct_keys(keys); end
@@ -4461,16 +4461,16 @@ class Prism::InstanceVariableOperatorWriteNode < Prism::Node
   def name_loc; end
 
   sig { returns(Prism::Location) }
-  def operator_loc; end
+  def binary_operator_loc; end
 
   sig { returns(Prism::Node) }
   def value; end
 
   sig { returns(Symbol) }
-  def operator; end
+  def binary_operator; end
 
-  sig { params(source: Prism::Source, name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, operator: Symbol, location: Prism::Location).void }
-  def initialize(source, name, name_loc, operator_loc, value, operator, location); end
+  sig { params(source: Prism::Source, name: Symbol, name_loc: Prism::Location, binary_operator_loc: Prism::Location, value: Prism::Node, binary_operator: Symbol, location: Prism::Location).void }
+  def initialize(source, name, name_loc, binary_operator_loc, value, binary_operator, location); end
 
   sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
   def accept(visitor); end
@@ -4487,8 +4487,8 @@ class Prism::InstanceVariableOperatorWriteNode < Prism::Node
   sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
   def comment_targets; end
 
-  sig { params(name: Symbol, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, operator: Symbol, location: Prism::Location).returns(Prism::InstanceVariableOperatorWriteNode) }
-  def copy(name: self.name, name_loc: self.name_loc, operator_loc: self.operator_loc, value: self.value, operator: self.operator, location: self.location); end
+  sig { params(name: Symbol, name_loc: Prism::Location, binary_operator_loc: Prism::Location, value: Prism::Node, binary_operator: Symbol, location: Prism::Location).returns(Prism::InstanceVariableOperatorWriteNode) }
+  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); end
 
   sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
   def deconstruct_keys(keys); end
@@ -5380,7 +5380,7 @@ class Prism::LocalVariableOperatorWriteNode < Prism::Node
   def name_loc; end
 
   sig { returns(Prism::Location) }
-  def operator_loc; end
+  def binary_operator_loc; end
 
   sig { returns(Prism::Node) }
   def value; end
@@ -5389,13 +5389,13 @@ class Prism::LocalVariableOperatorWriteNode < Prism::Node
   def name; end
 
   sig { returns(Symbol) }
-  def operator; end
+  def binary_operator; end
 
   sig { returns(Integer) }
   def depth; end
 
-  sig { params(source: Prism::Source, name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, name: Symbol, operator: Symbol, depth: Integer, location: Prism::Location).void }
-  def initialize(source, name_loc, operator_loc, value, name, operator, depth, location); end
+  sig { params(source: Prism::Source, name_loc: Prism::Location, binary_operator_loc: Prism::Location, value: Prism::Node, name: Symbol, binary_operator: Symbol, depth: Integer, location: Prism::Location).void }
+  def initialize(source, name_loc, binary_operator_loc, value, name, binary_operator, depth, location); end
 
   sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
   def accept(visitor); end
@@ -5412,8 +5412,8 @@ class Prism::LocalVariableOperatorWriteNode < Prism::Node
   sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
   def comment_targets; end
 
-  sig { params(name_loc: Prism::Location, operator_loc: Prism::Location, value: Prism::Node, name: Symbol, operator: Symbol, depth: Integer, location: Prism::Location).returns(Prism::LocalVariableOperatorWriteNode) }
-  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); end
+  sig { params(name_loc: Prism::Location, binary_operator_loc: Prism::Location, value: Prism::Node, name: Symbol, binary_operator: Symbol, depth: Integer, location: Prism::Location).returns(Prism::LocalVariableOperatorWriteNode) }
+  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); end
 
   sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }
   def deconstruct_keys(keys); end
@@ -6508,7 +6508,7 @@ class Prism::ParametersNode < Prism::Node
   sig { returns(T.nilable(T.any(Prism::RestParameterNode, Prism::ImplicitRestNode))) }
   def rest; end
 
-  sig { returns(T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode, Prism::KeywordRestParameterNode, Prism::NoKeywordsParameterNode)]) }
+  sig { returns(T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode, Prism::KeywordRestParameterNode, Prism::NoKeywordsParameterNode, Prism::ForwardingParameterNode)]) }
   def posts; end
 
   sig { returns(T::Array[T.any(Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode)]) }
@@ -6520,7 +6520,7 @@ class Prism::ParametersNode < Prism::Node
   sig { returns(T.nilable(Prism::BlockParameterNode)) }
   def block; end
 
-  sig { params(source: Prism::Source, requireds: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode)], optionals: T::Array[Prism::OptionalParameterNode], rest: T.nilable(T.any(Prism::RestParameterNode, Prism::ImplicitRestNode)), posts: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode, Prism::KeywordRestParameterNode, Prism::NoKeywordsParameterNode)], keywords: T::Array[T.any(Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode)], keyword_rest: T.nilable(T.any(Prism::KeywordRestParameterNode, Prism::ForwardingParameterNode, Prism::NoKeywordsParameterNode)), block: T.nilable(Prism::BlockParameterNode), location: Prism::Location).void }
+  sig { params(source: Prism::Source, requireds: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode)], optionals: T::Array[Prism::OptionalParameterNode], rest: T.nilable(T.any(Prism::RestParameterNode, Prism::ImplicitRestNode)), posts: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode, Prism::KeywordRestParameterNode, Prism::NoKeywordsParameterNode, Prism::ForwardingParameterNode)], keywords: T::Array[T.any(Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode)], keyword_rest: T.nilable(T.any(Prism::KeywordRestParameterNode, Prism::ForwardingParameterNode, Prism::NoKeywordsParameterNode)), block: T.nilable(Prism::BlockParameterNode), location: Prism::Location).void }
   def initialize(source, requireds, optionals, rest, posts, keywords, keyword_rest, block, location); end
 
   sig { override.params(visitor: Prism::Visitor).returns(T.untyped) }
@@ -6538,7 +6538,7 @@ class Prism::ParametersNode < Prism::Node
   sig { override.returns(T::Array[T.any(Prism::Node, Prism::Location)]) }
   def comment_targets; end
 
-  sig { params(requireds: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode)], optionals: T::Array[Prism::OptionalParameterNode], rest: T.nilable(T.any(Prism::RestParameterNode, Prism::ImplicitRestNode)), posts: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode, Prism::KeywordRestParameterNode, Prism::NoKeywordsParameterNode)], keywords: T::Array[T.any(Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode)], keyword_rest: T.nilable(T.any(Prism::KeywordRestParameterNode, Prism::ForwardingParameterNode, Prism::NoKeywordsParameterNode)), block: T.nilable(Prism::BlockParameterNode), location: Prism::Location).returns(Prism::ParametersNode) }
+  sig { params(requireds: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode)], optionals: T::Array[Prism::OptionalParameterNode], rest: T.nilable(T.any(Prism::RestParameterNode, Prism::ImplicitRestNode)), posts: T::Array[T.any(Prism::RequiredParameterNode, Prism::MultiTargetNode, Prism::KeywordRestParameterNode, Prism::NoKeywordsParameterNode, Prism::ForwardingParameterNode)], keywords: T::Array[T.any(Prism::RequiredKeywordParameterNode, Prism::OptionalKeywordParameterNode)], keyword_rest: T.nilable(T.any(Prism::KeywordRestParameterNode, Prism::ForwardingParameterNode, Prism::NoKeywordsParameterNode)), block: T.nilable(Prism::BlockParameterNode), location: Prism::Location).returns(Prism::ParametersNode) }
   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); end
 
   sig { params(keys: T.nilable(T::Array[Symbol])).returns(T::Hash[Symbol, T.untyped]) }

data/rbi/prism/node_ext.rbi

@@ -100,3 +100,8 @@ class Prism::ParametersNode < Prism::Node
   sig { returns(T::Array[T.any([Symbol, Symbol], [Symbol])]) }
   def signature; end
 end
+
+class Prism::CallNode < Prism::Node
+  sig { returns(T.nilable(Prism::Location)) }
+  def full_message_loc; end
+end

data/rbi/prism/parse_result.rbi

@@ -16,7 +16,7 @@ class Prism::Source
   sig { returns(Encoding) }
   def encoding; end
 
-  sig { returns(T::Array[Integer]) }
+  sig { returns(T::Array[String]) }
   def lines; end
 
   sig { params(byte_offset: Integer, length: Integer).returns(String) }

data/sig/prism/dsl.rbs

@@ -67,7 +67,7 @@ module Prism
     def CallNode: (Integer flags, Prism::node? receiver, Location? call_operator_loc, Symbol name, Location? message_loc, Location? opening_loc, ArgumentsNode? arguments, Location? closing_loc, Prism::node? block, ?Source source, ?Location location) -> CallNode
 
     # Create a new CallOperatorWriteNode node
-    def CallOperatorWriteNode: (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, ?Source source, ?Location location) -> CallOperatorWriteNode
+    def CallOperatorWriteNode: (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, ?Source source, ?Location location) -> CallOperatorWriteNode
 
     # Create a new CallOrWriteNode node
     def CallOrWriteNode: (Integer flags, Prism::node? receiver, Location? call_operator_loc, Location? message_loc, Symbol read_name, Symbol write_name, Location operator_loc, Prism::node value, ?Source source, ?Location location) -> CallOrWriteNode
@@ -91,7 +91,7 @@ module Prism
     def ClassVariableAndWriteNode: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, ?Source source, ?Location location) -> ClassVariableAndWriteNode
 
     # Create a new ClassVariableOperatorWriteNode node
-    def ClassVariableOperatorWriteNode: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Symbol operator, ?Source source, ?Location location) -> ClassVariableOperatorWriteNode
+    def ClassVariableOperatorWriteNode: (Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator, ?Source source, ?Location location) -> ClassVariableOperatorWriteNode
 
     # Create a new ClassVariableOrWriteNode node
     def ClassVariableOrWriteNode: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, ?Source source, ?Location location) -> ClassVariableOrWriteNode
@@ -109,7 +109,7 @@ module Prism
     def ConstantAndWriteNode: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, ?Source source, ?Location location) -> ConstantAndWriteNode
 
     # Create a new ConstantOperatorWriteNode node
-    def ConstantOperatorWriteNode: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Symbol operator, ?Source source, ?Location location) -> ConstantOperatorWriteNode
+    def ConstantOperatorWriteNode: (Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator, ?Source source, ?Location location) -> ConstantOperatorWriteNode
 
     # Create a new ConstantOrWriteNode node
     def ConstantOrWriteNode: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, ?Source source, ?Location location) -> ConstantOrWriteNode
@@ -121,7 +121,7 @@ module Prism
     def ConstantPathNode: (Prism::node? parent, Symbol? name, Location delimiter_loc, Location name_loc, ?Source source, ?Location location) -> ConstantPathNode
 
     # Create a new ConstantPathOperatorWriteNode node
-    def ConstantPathOperatorWriteNode: (ConstantPathNode target, Location operator_loc, Prism::node value, Symbol operator, ?Source source, ?Location location) -> ConstantPathOperatorWriteNode
+    def ConstantPathOperatorWriteNode: (ConstantPathNode target, Location binary_operator_loc, Prism::node value, Symbol binary_operator, ?Source source, ?Location location) -> ConstantPathOperatorWriteNode
 
     # Create a new ConstantPathOrWriteNode node
     def ConstantPathOrWriteNode: (ConstantPathNode target, Location operator_loc, Prism::node value, ?Source source, ?Location location) -> ConstantPathOrWriteNode
@@ -187,7 +187,7 @@ module Prism
     def GlobalVariableAndWriteNode: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, ?Source source, ?Location location) -> GlobalVariableAndWriteNode
 
     # Create a new GlobalVariableOperatorWriteNode node
-    def GlobalVariableOperatorWriteNode: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Symbol operator, ?Source source, ?Location location) -> GlobalVariableOperatorWriteNode
+    def GlobalVariableOperatorWriteNode: (Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator, ?Source source, ?Location location) -> GlobalVariableOperatorWriteNode
 
     # Create a new GlobalVariableOrWriteNode node
     def GlobalVariableOrWriteNode: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, ?Source source, ?Location location) -> GlobalVariableOrWriteNode
@@ -226,7 +226,7 @@ module Prism
     def IndexAndWriteNode: (Integer flags, Prism::node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Prism::node? block, Location operator_loc, Prism::node value, ?Source source, ?Location location) -> IndexAndWriteNode
 
     # Create a new IndexOperatorWriteNode node
-    def IndexOperatorWriteNode: (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, ?Source source, ?Location location) -> IndexOperatorWriteNode
+    def IndexOperatorWriteNode: (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, ?Source source, ?Location location) -> IndexOperatorWriteNode
 
     # Create a new IndexOrWriteNode node
     def IndexOrWriteNode: (Integer flags, Prism::node? receiver, Location? call_operator_loc, Location opening_loc, ArgumentsNode? arguments, Location closing_loc, Prism::node? block, Location operator_loc, Prism::node value, ?Source source, ?Location location) -> IndexOrWriteNode
@@ -238,7 +238,7 @@ module Prism
     def InstanceVariableAndWriteNode: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, ?Source source, ?Location location) -> InstanceVariableAndWriteNode
 
     # Create a new InstanceVariableOperatorWriteNode node
-    def InstanceVariableOperatorWriteNode: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, Symbol operator, ?Source source, ?Location location) -> InstanceVariableOperatorWriteNode
+    def InstanceVariableOperatorWriteNode: (Symbol name, Location name_loc, Location binary_operator_loc, Prism::node value, Symbol binary_operator, ?Source source, ?Location location) -> InstanceVariableOperatorWriteNode
 
     # Create a new InstanceVariableOrWriteNode node
     def InstanceVariableOrWriteNode: (Symbol name, Location name_loc, Location operator_loc, Prism::node value, ?Source source, ?Location location) -> InstanceVariableOrWriteNode
@@ -286,7 +286,7 @@ module Prism
     def LocalVariableAndWriteNode: (Location name_loc, Location operator_loc, Prism::node value, Symbol name, Integer depth, ?Source source, ?Location location) -> LocalVariableAndWriteNode
 
     # Create a new LocalVariableOperatorWriteNode node
-    def LocalVariableOperatorWriteNode: (Location name_loc, Location operator_loc, Prism::node value, Symbol name, Symbol operator, Integer depth, ?Source source, ?Location location) -> LocalVariableOperatorWriteNode
+    def LocalVariableOperatorWriteNode: (Location name_loc, Location binary_operator_loc, Prism::node value, Symbol name, Symbol binary_operator, Integer depth, ?Source source, ?Location location) -> LocalVariableOperatorWriteNode
 
     # Create a new LocalVariableOrWriteNode node
     def LocalVariableOrWriteNode: (Location name_loc, Location operator_loc, Prism::node value, Symbol name, Integer depth, ?Source source, ?Location location) -> LocalVariableOrWriteNode
@@ -349,7 +349,7 @@ module Prism
     def OrNode: (Prism::node left, Prism::node right, Location operator_loc, ?Source source, ?Location location) -> OrNode
 
     # Create a new ParametersNode node
-    def ParametersNode: (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, ?Source source, ?Location location) -> ParametersNode
+    def ParametersNode: (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, ?Source source, ?Location location) -> ParametersNode
 
     # Create a new ParenthesesNode node
     def ParenthesesNode: (Prism::node? body, Location opening_loc, Location closing_loc, ?Source source, ?Location location) -> ParenthesesNode

data/sig/prism/lex_compat.rbs

@@ -0,0 +1,10 @@
+module Prism
+  class LexCompat
+    class Result < Prism::Result
+      attr_reader value: Array[[[Integer, Integer], Symbol, String, untyped]]
+
+      def initialize: (Array[[[Integer, Integer], Symbol, String, untyped]] value, Array[comment] comments, Array[MagicComment] magic_comments, Location? data_loc, Array[ParseError] errors, Array[ParseWarning] warnings, Source source) -> void  
+      def deconstruct_keys: (Array[Symbol]? keys) -> Hash[Symbol, untyped]
+    end
+  end
+end