[ruby/prism] operator rename

https://github.com/ruby/prism/commit/b5e47f5c42

3 files changed, 179 insertions, 49 deletions

diff --git a/lib/prism/translation/parser/compiler.rb b/lib/prism/translation/parser/compiler.rb
index c311613388..a6c3118efd 100644
--- a/lib/prism/translation/parser/compiler.rb
+++ b/lib/prism/translation/parser/compiler.rb
@@ -328,18 +328,48 @@ module Prism
               [],
               nil
             ),
-            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
             visit(node.value)
           )
         end
 
         # foo.bar &&= baz
         # ^^^^^^^^^^^^^^^
-        alias visit_call_and_write_node visit_call_operator_write_node
+        def visit_call_and_write_node(node)
+          call_operator_loc = node.call_operator_loc
+
+          builder.op_assign(
+            builder.call_method(
+              visit(node.receiver),
+              call_operator_loc.nil? ? nil : [{ "." => :dot, "&." => :anddot, "::" => "::" }.fetch(call_operator_loc.slice), srange(call_operator_loc)],
+              node.message_loc ? [node.read_name, srange(node.message_loc)] : nil,
+              nil,
+              [],
+              nil
+            ),
+            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            visit(node.value)
+          )
+        end
 
         # foo.bar ||= baz
         # ^^^^^^^^^^^^^^^
-        alias visit_call_or_write_node visit_call_operator_write_node
+        def visit_call_or_write_node(node)
+          call_operator_loc = node.call_operator_loc
+
+          builder.op_assign(
+            builder.call_method(
+              visit(node.receiver),
+              call_operator_loc.nil? ? nil : [{ "." => :dot, "&." => :anddot, "::" => "::" }.fetch(call_operator_loc.slice), srange(call_operator_loc)],
+              node.message_loc ? [node.read_name, srange(node.message_loc)] : nil,
+              nil,
+              [],
+              nil
+            ),
+            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            visit(node.value)
+          )
+        end
 
         # foo.bar, = 1
         # ^^^^^^^
@@ -419,18 +449,30 @@ module Prism
         def visit_class_variable_operator_write_node(node)
           builder.op_assign(
             builder.assignable(builder.cvar(token(node.name_loc))),
-            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
             visit(node.value)
           )
         end
 
         # @@foo &&= bar
         # ^^^^^^^^^^^^^
-        alias visit_class_variable_and_write_node visit_class_variable_operator_write_node
+        def visit_class_variable_and_write_node(node)
+          builder.op_assign(
+            builder.assignable(builder.cvar(token(node.name_loc))),
+            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            visit(node.value)
+          )
+        end
 
         # @@foo ||= bar
         # ^^^^^^^^^^^^^
-        alias visit_class_variable_or_write_node visit_class_variable_operator_write_node
+        def visit_class_variable_or_write_node(node)
+          builder.op_assign(
+            builder.assignable(builder.cvar(token(node.name_loc))),
+            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            visit(node.value)
+          )
+        end
 
         # @@foo, = bar
         # ^^^^^
@@ -458,18 +500,30 @@ module Prism
         def visit_constant_operator_write_node(node)
           builder.op_assign(
             builder.assignable(builder.const([node.name, srange(node.name_loc)])),
-            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
             visit(node.value)
           )
         end
 
         # Foo &&= bar
         # ^^^^^^^^^^^^
-        alias visit_constant_and_write_node visit_constant_operator_write_node
+        def visit_constant_and_write_node(node)
+          builder.op_assign(
+            builder.assignable(builder.const([node.name, srange(node.name_loc)])),
+            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            visit(node.value)
+          )
+        end
 
         # Foo ||= bar
         # ^^^^^^^^^^^^
-        alias visit_constant_or_write_node visit_constant_operator_write_node
+        def visit_constant_or_write_node(node)
+          builder.op_assign(
+            builder.assignable(builder.const([node.name, srange(node.name_loc)])),
+            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            visit(node.value)
+          )
+        end
 
         # Foo, = bar
         # ^^^
@@ -512,18 +566,30 @@ module Prism
         def visit_constant_path_operator_write_node(node)
           builder.op_assign(
             builder.assignable(visit(node.target)),
-            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
             visit(node.value)
           )
         end
 
         # Foo::Bar &&= baz
         # ^^^^^^^^^^^^^^^^
-        alias visit_constant_path_and_write_node visit_constant_path_operator_write_node
+        def visit_constant_path_and_write_node(node)
+          builder.op_assign(
+            builder.assignable(visit(node.target)),
+            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            visit(node.value)
+          )
+        end
 
         # Foo::Bar ||= baz
         # ^^^^^^^^^^^^^^^^
-        alias visit_constant_path_or_write_node visit_constant_path_operator_write_node
+        def visit_constant_path_or_write_node(node)
+          builder.op_assign(
+            builder.assignable(visit(node.target)),
+            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            visit(node.value)
+          )
+        end
 
         # Foo::Bar, = baz
         # ^^^^^^^^
@@ -711,18 +777,30 @@ module Prism
         def visit_global_variable_operator_write_node(node)
           builder.op_assign(
             builder.assignable(builder.gvar(token(node.name_loc))),
-            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
             visit(node.value)
           )
         end
 
         # $foo &&= bar
         # ^^^^^^^^^^^^
-        alias visit_global_variable_and_write_node visit_global_variable_operator_write_node
+        def visit_global_variable_and_write_node(node)
+          builder.op_assign(
+            builder.assignable(builder.gvar(token(node.name_loc))),
+            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            visit(node.value)
+          )
+        end
 
         # $foo ||= bar
         # ^^^^^^^^^^^^
-        alias visit_global_variable_or_write_node visit_global_variable_operator_write_node
+        def visit_global_variable_or_write_node(node)
+          builder.op_assign(
+            builder.assignable(builder.gvar(token(node.name_loc))),
+            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            visit(node.value)
+          )
+        end
 
         # $foo, = bar
         # ^^^^
@@ -857,18 +935,46 @@ module Prism
               visit_all(arguments),
               token(node.closing_loc)
             ),
-            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
             visit(node.value)
           )
         end
 
         # foo[bar] &&= baz
         # ^^^^^^^^^^^^^^^^
-        alias visit_index_and_write_node visit_index_operator_write_node
+        def visit_index_and_write_node(node)
+          arguments = node.arguments&.arguments || []
+          arguments << node.block if node.block
+
+          builder.op_assign(
+            builder.index(
+              visit(node.receiver),
+              token(node.opening_loc),
+              visit_all(arguments),
+              token(node.closing_loc)
+            ),
+            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            visit(node.value)
+          )
+        end
 
         # foo[bar] ||= baz
         # ^^^^^^^^^^^^^^^^
-        alias visit_index_or_write_node visit_index_operator_write_node
+        def visit_index_or_write_node(node)
+          arguments = node.arguments&.arguments || []
+          arguments << node.block if node.block
+
+          builder.op_assign(
+            builder.index(
+              visit(node.receiver),
+              token(node.opening_loc),
+              visit_all(arguments),
+              token(node.closing_loc)
+            ),
+            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            visit(node.value)
+          )
+        end
 
         # foo[bar], = 1
         # ^^^^^^^^
@@ -902,18 +1008,30 @@ module Prism
         def visit_instance_variable_operator_write_node(node)
           builder.op_assign(
             builder.assignable(builder.ivar(token(node.name_loc))),
-            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
             visit(node.value)
           )
         end
 
         # @foo &&= bar
         # ^^^^^^^^^^^^
-        alias visit_instance_variable_and_write_node visit_instance_variable_operator_write_node
+        def visit_instance_variable_and_write_node(node)
+          builder.op_assign(
+            builder.assignable(builder.ivar(token(node.name_loc))),
+            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            visit(node.value)
+          )
+        end
 
         # @foo ||= bar
         # ^^^^^^^^^^^^
-        alias visit_instance_variable_or_write_node visit_instance_variable_operator_write_node
+        def visit_instance_variable_or_write_node(node)
+          builder.op_assign(
+            builder.assignable(builder.ivar(token(node.name_loc))),
+            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            visit(node.value)
+          )
+        end
 
         # @foo, = bar
         # ^^^^
@@ -1108,18 +1226,30 @@ module Prism
         def visit_local_variable_operator_write_node(node)
           builder.op_assign(
             builder.assignable(builder.ident(token(node.name_loc))),
-            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            [node.binary_operator_loc.slice.chomp("="), srange(node.binary_operator_loc)],
             visit(node.value)
           )
         end
 
         # foo &&= bar
         # ^^^^^^^^^^^
-        alias visit_local_variable_and_write_node visit_local_variable_operator_write_node
+        def visit_local_variable_and_write_node(node)
+          builder.op_assign(
+            builder.assignable(builder.ident(token(node.name_loc))),
+            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            visit(node.value)
+          )
+        end
 
         # foo ||= bar
         # ^^^^^^^^^^^
-        alias visit_local_variable_or_write_node visit_local_variable_operator_write_node
+        def visit_local_variable_or_write_node(node)
+          builder.op_assign(
+            builder.assignable(builder.ident(token(node.name_loc))),
+            [node.operator_loc.slice.chomp("="), srange(node.operator_loc)],
+            visit(node.value)
+          )
+        end
 
         # foo, = bar
         # ^^^
diff --git a/lib/prism/translation/ripper.rb b/lib/prism/translation/ripper.rb
index d226bb58df..68f658565d 100644
--- a/lib/prism/translation/ripper.rb
+++ b/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)
diff --git a/lib/prism/translation/ruby_parser.rb b/lib/prism/translation/ruby_parser.rb
index c6f741c8e5..d01a762a03 100644
--- a/lib/prism/translation/ruby_parser.rb
+++ b/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