ruby-next-core 0.10.5 → 0.13.0

data/lib/.rbnext/2.3/ruby-next/language/rewriters/base.rb

@@ -60,7 +60,7 @@ module RubyNext
             eval_mid = Kernel.respond_to?(:eval_without_ruby_next) ? :eval_without_ruby_next : :eval
             Kernel.send eval_mid, self::SYNTAX_PROBE, nil, __FILE__, __LINE__
             false
-          rescue SyntaxError, NameError
+          rescue SyntaxError, StandardError
             true
           ensure
             $VERBOSE = save_verbose
@@ -93,20 +93,38 @@ module RubyNext
 
         private
 
+        # BFS with predicate block
+        def find_child(node)
+          queue = [node]
+
+          loop do
+            break if queue.empty?
+
+            child = queue.shift
+            next unless child.is_a?(::Parser::AST::Node)
+
+            return child if yield child
+
+            queue.push(*child.children)
+          end
+
+          nil
+        end
+
         def replace(range, ast)
-          ((!@source_rewriter.nil? || nil) && @source_rewriter.replace(range, unparse(ast)))
+          ((((__safe_lvar__ = @source_rewriter) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.replace(range, unparse(ast)))
         end
 
         def remove(range)
-          ((!@source_rewriter.nil? || nil) && @source_rewriter.remove(range))
+          ((((__safe_lvar__ = @source_rewriter) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.remove(range))
         end
 
         def insert_after(range, ast)
-          ((!@source_rewriter.nil? || nil) && @source_rewriter.insert_after(range, unparse(ast)))
+          ((((__safe_lvar__ = @source_rewriter) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.insert_after(range, unparse(ast)))
         end
 
         def insert_before(range, ast)
-          ((!@source_rewriter.nil? || nil) && @source_rewriter.insert_before(range, unparse(ast)))
+          ((((__safe_lvar__ = @source_rewriter) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.insert_before(range, unparse(ast)))
         end
 
         def unparse(ast)

data/lib/.rbnext/2.3/ruby-next/language/rewriters/endless_range.rb

@@ -55,7 +55,7 @@ module RubyNext
         attr_reader :current_index
 
         def index_arg?(node)
-          ((!((!current_index.nil? || nil) && current_index.children).nil? || nil) && ((!current_index.nil? || nil) && current_index.children).include?(node))
+          ((((__safe_lvar__ = ((((__safe_lvar__ = current_index) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.children)) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.include?(node))
         end
       end
     end

data/lib/.rbnext/2.3/ruby-next/language/rewriters/pattern_matching.rb

@@ -13,12 +13,12 @@ module RubyNext
 
           # Useful to generate simple operation nodes
           # (e.g., 'a + b')
-          def -(val)
-            ::Parser::AST::Node.new(:send, [self, :-, val.to_ast_node])
+          def -(other)
+            ::Parser::AST::Node.new(:send, [self, :-, other.to_ast_node])
           end
 
-          def +(val)
-            ::Parser::AST::Node.new(:send, [self, :+, val.to_ast_node])
+          def +(other)
+            ::Parser::AST::Node.new(:send, [self, :+, other.to_ast_node])
           end
         end
 
@@ -218,9 +218,10 @@ module RubyNext
             predicate_clause(:respond_to_deconstruct_keys, node)
           end
 
-          def hash_key(node, key)
-            key = key.children.first if key.is_a?(::Parser::AST::Node)
-            predicate_clause(:"hash_key_#{key}", node)
+          def hash_keys(node, keys)
+            keys = keys.map { |key| key.is_a?(::Parser::AST::Node) ? key.children.first : key }
+
+            predicate_clause(:"hash_keys_#{keys.join("_p_")}", node)
           end
         end
       end
@@ -266,7 +267,7 @@ module RubyNext
           )
         end
 
-        def on_in_match(node)
+        def on_match_pattern(node)
           context.track! self
 
           @deconstructed_keys = {}
@@ -303,6 +304,8 @@ module RubyNext
           end
         end
 
+        alias on_in_match on_match_pattern
+
         private
 
         def rewrite_case_in!(node, matchee, new_node)
@@ -310,7 +313,7 @@ module RubyNext
           remove(node.children[0].loc.expression)
 
           node.children[1..-1].each.with_index do |clause, i|
-            if ((!clause.nil? || nil) && clause.type) == :in_pattern
+            if ((((__safe_lvar__ = clause) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.type) == :in_pattern
               # handle multiline clauses differently
               if clause.loc.last_line > clause.children[0].loc.last_line + 1
                 height = clause.loc.last_line - clause.children[0].loc.last_line
@@ -341,7 +344,7 @@ module RubyNext
           clauses = []
 
           nodes.each do |clause|
-            if ((!clause.nil? || nil) && clause.type) == :in_pattern
+            if ((((__safe_lvar__ = clause) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.type) == :in_pattern
               clauses << build_when_clause(clause)
             else
               else_clause = process(clause)
@@ -350,7 +353,7 @@ module RubyNext
 
           else_clause = (else_clause || no_matching_pattern).then do |node|
             next node unless node.type == :empty_else
-            s(:empty)
+            nil
           end
 
           clauses << else_clause
@@ -883,14 +886,14 @@ module RubyNext
         end
 
         def having_hash_keys(keys, hash = s(:lvar, locals[:hash]))
-          key = keys.shift
-          node = predicates.hash_key(hash_has_key(key, hash), key)
+          keys.reduce(nil) do |acc, key|
+            pnode = hash_has_key(key, hash)
+            next pnode unless acc
 
-          keys.reduce(node) do |res, key|
             s(:begin,
-              s(:and,
-                res,
-                predicates.hash_key(hash_has_key(key, hash), key)))
+              s(:and, acc, pnode))
+          end.then do |node|
+            predicates.hash_keys(node, keys)
           end
         end
 

data/lib/.rbnext/2.3/ruby-next/utils.rb

@@ -6,7 +6,7 @@ module RubyNext
 
     if $LOAD_PATH.respond_to?(:resolve_feature_path)
       def resolve_feature_path(feature)
-        ((!$LOAD_PATH.resolve_feature_path(feature).nil? || nil) && $LOAD_PATH.resolve_feature_path(feature).last)
+        ((((__safe_lvar__ = $LOAD_PATH.resolve_feature_path(feature)) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.last)
       rescue LoadError
       end
     else

data/lib/.rbnext/2.7/ruby-next/core.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require "set"
+
+require "ruby-next/config"
+require "ruby-next/utils"
+
+module RubyNext
+  module Core
+    # Patch contains the extension implementation
+    # and meta information (e.g., Ruby version).
+    class Patch
+      attr_reader :refineables, :name, :mod, :method_name, :version, :body, :singleton, :core_ext, :supported, :native, :location
+
+      # Create a new patch for module/class (mod)
+      # with the specified uniq name
+      #
+      # `core_ext` defines the strategy for core extensions:
+      #    - :patch — extend class directly
+      #    - :prepend — extend class by prepending a module (e.g., when needs `super`)
+      def initialize(mod = nil, method:, version:, name: nil, supported: nil, native: nil, location: nil, refineable: mod, core_ext: :patch, singleton: nil)
+        @mod = mod
+        @method_name = method
+        @version = version
+        if method_name && mod
+          @supported = supported.nil? ? mod.method_defined?(method_name) : supported
+          # define whether running Ruby has a native implementation for this method
+          # for that, we check the source_location (which is nil for C defined methods)
+          @native = native.nil? ? (supported? && native_location?(mod.instance_method(method_name).source_location)) : native
+        end
+        @singleton = singleton
+        @refineables = Array(refineable)
+        @body = yield
+        @core_ext = core_ext
+        @location = location || build_location(caller_locations(1, 5))
+        @name = name || build_module_name
+      end
+
+      def prepend?
+        core_ext == :prepend
+      end
+
+      def core_ext?
+        !mod.nil?
+      end
+
+      alias supported? supported
+      alias native? native
+      alias singleton? singleton
+
+      def to_module
+        Module.new.tap do |ext|
+          ext.module_eval(body, *location)
+
+          RubyNext::Core.const_set(name, ext)
+        end
+      end
+
+      private
+
+      def build_module_name
+        mod_name = singleton? ? singleton.name : mod.name
+        camelized_method_name = method_name.to_s.split("_").map(&:capitalize).join
+
+        "#{mod_name}#{camelized_method_name}".gsub(/\W/, "")
+      end
+
+      def build_location(trace_locations)
+        # The caller_locations behaviour depends on implementaion,
+        # e.g. in JRuby https://github.com/jruby/jruby/issues/6055
+        while trace_locations.first.label != "patch"
+          trace_locations.shift
+        end
+
+        trace_location = trace_locations[1]
+
+        [trace_location.absolute_path, trace_location.lineno + 2]
+      end
+
+      def native_location?(location)
+        location.nil? || location.first.match?(/(<internal:|resource:\/truffleruby\/core)/)
+      end
+    end
+
+    # Registry for patches
+    class Patches
+      attr_reader :extensions, :refined
+
+      def initialize
+        @names = Set.new
+        @extensions = Hash.new { |h, k| h[k] = [] }
+        @refined = Hash.new { |h, k| h[k] = [] }
+      end
+
+      # Register new patch
+      def <<(patch)
+        raise ArgumentError, "Patch already registered: #{patch.name}" if @names.include?(patch.name)
+        @names << patch.name
+        @extensions[patch.mod] << patch if patch.core_ext?
+        patch.refineables.each { |r| @refined[r] << patch } unless patch.native?
+      end
+    end
+
+    class << self
+      STRATEGIES = %i[refine core_ext backports].freeze
+
+      attr_reader :strategy
+
+      def strategy=(val)
+        raise ArgumentError, "Unknown strategy: #{val}. Available: #{STRATEGIES.join(",")}" unless STRATEGIES.include?(val)
+        @strategy = val
+      end
+
+      def refine?
+        strategy == :refine
+      end
+
+      def core_ext?
+        strategy == :core_ext || strategy == :backports
+      end
+
+      def backports?
+        strategy == :backports
+      end
+
+      def patch(*__rest__, &__block__)
+        patches << Patch.new(*__rest__, &__block__)
+      end
+
+      # Inject `using RubyNext` at the top of the source code
+      def inject!(contents)
+        if contents.frozen?
+          contents = contents.sub(/^(\s*[^#\s].*)/, 'using RubyNext;\1')
+        else
+          contents.sub!(/^(\s*[^#\s].*)/, 'using RubyNext;\1')
+        end
+        contents
+      end
+
+      def patches
+        @patches ||= Patches.new
+      end
+    end
+
+    # Use refinements by default
+    self.strategy = ENV.fetch("RUBY_NEXT_CORE_STRATEGY", "refine").to_sym
+  end
+end
+
+require "backports/2.5" if RubyNext::Core.backports?
+
+require "ruby-next/core/kernel/then"
+
+require "ruby-next/core/proc/compose"
+
+require "ruby-next/core/enumerable/tally"
+require "ruby-next/core/enumerable/filter"
+require "ruby-next/core/enumerable/filter_map"
+
+require "ruby-next/core/enumerator/produce"
+
+require "ruby-next/core/array/difference_union_intersection"
+
+require "ruby-next/core/hash/merge"
+
+require "ruby-next/core/string/split"
+
+require "ruby-next/core/symbol/start_with"
+require "ruby-next/core/symbol/end_with"
+
+require "ruby-next/core/unboundmethod/bind_call"
+
+require "ruby-next/core/time/floor"
+require "ruby-next/core/time/ceil"
+
+# Core extensions required for pattern matching
+# Required for pattern matching with refinements
+unless defined?(NoMatchingPatternError)
+  class NoMatchingPatternError < StandardError
+  end
+end
+
+require "ruby-next/core/constants/no_matching_pattern_error"
+require "ruby-next/core/constants/frozen_error"
+require "ruby-next/core/array/deconstruct"
+require "ruby-next/core/hash/deconstruct_keys"
+require "ruby-next/core/struct/deconstruct"
+require "ruby-next/core/struct/deconstruct_keys"
+
+require "ruby-next/core/hash/except"
+
+require "ruby-next/core/array/intersect"
+
+# Generate refinements
+RubyNext.module_eval do
+  RubyNext::Core.patches.refined.each do |mod, patches|
+    # Only refine modules when supported
+    next unless mod.is_a?(Class) || RubyNext::Utils.refine_modules?
+
+    refine mod do
+      patches.each do |patch|
+        module_eval(patch.body, *patch.location)
+      end
+    end
+  end
+end

data/lib/ruby-next/commands/nextify.rb

@@ -57,7 +57,7 @@ module RubyNext
 
           opts.on(
             "--transpile-mode=MODE",
-            "Transpiler mode (ast or rewrite). Default: ast"
+            "Transpiler mode (ast or rewrite). Default: rewrite"
           ) do |val|
             Language.mode = val.to_sym
           end

data/lib/ruby-next/config.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RubyNext
+  # Mininum Ruby version supported by RubyNext
+  MIN_SUPPORTED_VERSION = Gem::Version.new("2.2.0")
+
+  # Where to store transpiled files (relative from the project LOAD_PATH, usually `lib/`)
+  RUBY_NEXT_DIR = ".rbnext"
+
+  # Defines last minor version for every major version
+  LAST_MINOR_VERSIONS = {
+    2 => 8, # 2.8 is required for backward compatibility: some gems already uses it
+    3 => 0
+  }.freeze
+
+  LATEST_VERSION = [3, 0].freeze
+
+  # A virtual version number used for proposed features
+  NEXT_VERSION = "1995.next.0"
+
+  class << self
+    # TruffleRuby claims it's 2.7.2 compatible but...
+    if defined?(TruffleRuby) && ::RUBY_VERSION =~ /^2\.7/
+      def current_ruby_version
+        "2.6.5"
+      end
+    else
+      def current_ruby_version
+        ::RUBY_VERSION
+      end
+    end
+
+    def next_ruby_version(version = current_ruby_version)
+      return if version == Gem::Version.new(NEXT_VERSION)
+
+      major, minor = Gem::Version.new(version).segments.map(&:to_i)
+
+      return Gem::Version.new(NEXT_VERSION) if major >= LATEST_VERSION.first && minor >= LATEST_VERSION.last
+
+      nxt =
+        if LAST_MINOR_VERSIONS[major] == minor
+          "#{major + 1}.0.0"
+        else
+          "#{major}.#{minor + 1}.0"
+        end
+
+      Gem::Version.new(nxt)
+    end
+  end
+end

data/lib/ruby-next/core/array/deconstruct.rb

@@ -9,7 +9,7 @@ end
 end
 
 # We need to hack `respond_to?` in Ruby 2.5, since it's not working with refinements
-if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.6")
+if Gem::Version.new(::RubyNext.current_ruby_version) < Gem::Version.new("2.6")
   RubyNext::Core.patch refineable: Array, name: "ArrayRespondToDeconstruct", method: :deconstruct, version: "2.7" do
     <<-RUBY
 def respond_to?(mid, *)

data/lib/ruby-next/core/array/intersect.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RubyNext::Core.patch Array, method: :intersect?, version: "3.1" do
+  <<-RUBY
+def intersect?(other)
+  !(self & other).empty?
+end
+  RUBY
+end

data/lib/ruby-next/core/constants/frozen_error.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+RubyNext::Core.patch Object,
+  name: "FrozenError",
+  method: nil,
+  refineable: [],
+  version: "2.5",
+  # avoid defining the constant twice, 'causae it's already included in core
+  # we only use the contents in `ruby-next core_ext`.
+  supported: true,
+  location: [__FILE__, __LINE__ + 2] do
+  <<-RUBY
+FrozenError ||= RuntimeError
+  RUBY
+end

data/lib/ruby-next/core/constants/no_matching_pattern_error.rb

@@ -11,7 +11,7 @@ RubyNext::Core.patch Object,
   supported: true,
   location: [__FILE__, __LINE__ + 2] do
   <<-RUBY
-class NoMatchingPatternError < RuntimeError
+class NoMatchingPatternError < StandardError
 end
   RUBY
 end

data/lib/ruby-next/core/enumerable/tally.rb

@@ -1,12 +1,51 @@
 # frozen_string_literal: true
 
-# Refine Array seprately, 'cause refining modules is vulnerable to prepend:
-# - https://bugs.ruby-lang.org/issues/13446
-RubyNext::Core.patch Enumerable, method: :tally, version: "2.7", refineable: [Enumerable, Array] do
-  <<-RUBY
-def tally
-  each_with_object({}) do |v, acc|
-    acc[v] ||= 0
+# Ruby 3.1 adds an ability to pass a hash as accumulator.
+#
+# NOTE: We have separate patches for MRI 3.0+ and others due to the unsupported refinements vs modules behaviour.
+if Enumerable.method_defined?(:tally) && ([].method(:tally).arity == 0) && !(defined?(JRUBY_VERSION) || defined?(TruffleRuby))
+  RubyNext::Core.patch name: "TallyWithHash", supported: false, native: nil, method: :tally, version: "3.1", refineable: [Enumerable] do
+    <<-'RUBY'
+  def tally(*attrs)
+    return super() if attrs.size.zero?
+
+    raise ArgumentError, "wrong number of arguments (given #{attrs.size}, expected 0..1)" if attrs.size > 1
+
+    hash = attrs.size.zero? ? {} : attrs[0].to_hash
+    raise FrozenError, "can't modify frozen #{hash.class}: #{hash}" if hash.frozen?
+
+    each_with_object(hash) do |v, acc|
+      acc[v] = 0 unless acc.key?(v)
+      acc[v] += 1
+    end
+  end
+    RUBY
+  end
+else
+  RubyNext::Core.patch Enumerable, method: :tally, version: "3.1", refineable: [Enumerable, Array] do
+    <<-'RUBY'
+  def tally(acc = {})
+    hash = acc.to_hash
+    raise FrozenError, "can't modify frozen #{hash.class}: #{hash}" if hash.frozen?
+
+    each_with_object(hash) do |v, acc|
+      acc[v] = 0 unless acc.key?(v)
+      acc[v] += 1
+    end
+  end
+    RUBY
+  end
+end
+
+# This patch is intended for core extensions only (since we can not use prepend here)
+RubyNext::Core.patch Enumerable, name: "TallyWithHashCoreExt", version: "3.1", supported: Enumerable.method_defined?(:tally) && ([].method(:tally).arity != 0), method: :tally, refineable: [] do
+  <<-'RUBY'
+def tally(acc = {})
+  hash = acc.to_hash
+  raise FrozenError, "can't modify frozen #{hash.class}: #{hash}" if hash.frozen?
+
+  each_with_object(hash) do |v, acc|
+    acc[v] = 0 unless acc.key?(v)
     acc[v] += 1
   end
 end

data/lib/ruby-next/core/hash/deconstruct_keys.rb

@@ -9,7 +9,7 @@ end
 end
 
 # We need to hack `respond_to?` in Ruby 2.5, since it's not working with refinements
-if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.6")
+if Gem::Version.new(::RubyNext.current_ruby_version) < Gem::Version.new("2.6")
   RubyNext::Core.patch refineable: Hash, name: "HashRespondToDeconstructKeys", method: :deconstruct_keys, version: "2.7" do
     <<-RUBY
 def respond_to?(mid, *)

data/lib/ruby-next/core/struct/deconstruct_keys.rb

@@ -10,9 +10,9 @@ def deconstruct_keys(keys)
 
   keys.each_with_object({}) do |k, acc|
     # if k is Symbol and not a member of a Struct return {}
-    next if (Symbol === k || String === k) && !members.include?(k.to_sym)
+    return {} if (Symbol === k || String === k) && !members.include?(k.to_sym)
     # if k is Integer check that index is not ouf of bounds
-    next if Integer === k && k > size - 1
+    return {} if Integer === k && k > size - 1
     acc[k] = self[k]
   end
 end
@@ -20,7 +20,7 @@ end
 end
 
 # We need to hack `respond_to?` in Ruby 2.5, since it's not working with refinements
-if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.6")
+if Gem::Version.new(::RubyNext.current_ruby_version) < Gem::Version.new("2.6")
   RubyNext::Core.patch refineable: Struct, name: "StructRespondToDeconstruct", method: :deconstruct_keys, version: "2.7" do
     <<-RUBY
 def respond_to?(mid, *)

data/lib/ruby-next/core.rb

@@ -2,6 +2,7 @@
 
 require "set"
 
+require "ruby-next/config"
 require "ruby-next/utils"
 
 module RubyNext
@@ -17,7 +18,7 @@ module RubyNext
       # `core_ext` defines the strategy for core extensions:
       #    - :patch — extend class directly
       #    - :prepend — extend class by prepending a module (e.g., when needs `super`)
-      def initialize(mod = nil, method:, name: nil, version:, supported: nil, native: nil, location: nil, refineable: mod, core_ext: :patch, singleton: nil)
+      def initialize(mod = nil, method:, version:, name: nil, supported: nil, native: nil, location: nil, refineable: mod, core_ext: :patch, singleton: nil)
         @mod = mod
         @method_name = method
         @version = version
@@ -122,8 +123,8 @@ module RubyNext
         strategy == :backports
       end
 
-      def patch(*args, **kwargs, &block)
-        patches << Patch.new(*args, **kwargs, &block)
+      def patch(...)
+        patches << Patch.new(...)
       end
 
       # Inject `using RubyNext` at the top of the source code
@@ -175,11 +176,12 @@ require "ruby-next/core/time/ceil"
 # Core extensions required for pattern matching
 # Required for pattern matching with refinements
 unless defined?(NoMatchingPatternError)
-  class NoMatchingPatternError < RuntimeError
+  class NoMatchingPatternError < StandardError
   end
 end
 
 require "ruby-next/core/constants/no_matching_pattern_error"
+require "ruby-next/core/constants/frozen_error"
 require "ruby-next/core/array/deconstruct"
 require "ruby-next/core/hash/deconstruct_keys"
 require "ruby-next/core/struct/deconstruct"
@@ -187,6 +189,8 @@ require "ruby-next/core/struct/deconstruct_keys"
 
 require "ruby-next/core/hash/except"
 
+require "ruby-next/core/array/intersect"
+
 # Generate refinements
 RubyNext.module_eval do
   RubyNext::Core.patches.refined.each do |mod, patches|

data/lib/ruby-next/core_ext.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "ruby-next/config"
+require "ruby-next/setup_self"
 require "ruby-next/core"
 
 # Monkey-patch core classes using the same patches as for refinements
@@ -8,7 +10,7 @@ RubyNext::Core.patches.extensions.each do |mod, patches|
     next if patch.supported?
 
     if patch.prepend?
-      mod.prepend(patch.to_module)
+      mod.send(:prepend, patch.to_module)
     else
       mod.module_eval(patch.body, *patch.location)
     end

data/lib/ruby-next/language/bootsnap.rb

@@ -13,7 +13,7 @@ load_iseq = RubyVM::InstructionSequence.method(:load_iseq)
 if load_iseq.source_location[0].include?("/bootsnap/")
   Bootsnap::CompileCache::ISeq.singleton_class.prepend(
     Module.new do
-      def input_to_storage(source, path)
+      def input_to_storage(source, path, *)
         return super unless RubyNext::Language.transformable?(path)
         source = RubyNext::Language.transform(source, rewriters: RubyNext::Language.current_rewriters)
 

data/lib/ruby-next/language/edge.rb

@@ -1,9 +1,3 @@
 # frozen_string_literal: true
 
 # Load edge Ruby features
-
-require "ruby-next/language/rewriters/endless_method"
-RubyNext::Language.rewriters << RubyNext::Language::Rewriters::EndlessMethod
-
-require "ruby-next/language/rewriters/right_hand_assignment"
-RubyNext::Language.rewriters << RubyNext::Language::Rewriters::RightHandAssignment