ruby-next-core 0.9.2 → 0.10.4

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

@@ -34,7 +34,7 @@ module RubyNext
           end
 
           def key?(name)
-            !!fetch(name) { false }
+            !!fetch(name) { false } # rubocop:disable Style/RedundantFetchBlock
           end
 
           def fetch(name)

data/lib/ruby-next/language/rewriters/endless_method.rb

@@ -6,7 +6,14 @@ module RubyNext
       class EndlessMethod < Base
         NAME = "endless-method"
         SYNTAX_PROBE = "obj = Object.new; def obj.foo() = 42"
-        MIN_SUPPORTED_VERSION = Gem::Version.new("2.8.0")
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.0.0")
+
+        unless Parser::Meta::NODE_TYPES.include?(:def_e)
+          def on_def(node)
+            return on_def_e(node) if node.loc.end.nil?
+            super(node)
+          end
+        end
 
         def on_def_e(node)
           context.track! self
@@ -14,24 +21,39 @@ module RubyNext
           replace(node.loc.assignment, "; ")
           insert_after(node.loc.expression, "; end")
 
+          new_loc = node.loc.dup
+          new_loc.instance_variable_set(:@end, node.loc.expression)
+
           process(
             node.updated(
               :def,
-              node.children
+              node.children,
+              location: new_loc
             )
           )
         end
 
+        unless Parser::Meta::NODE_TYPES.include?(:def_e)
+          def on_defs(node)
+            return on_defs_e(node) if node.loc.end.nil?
+            super(node)
+          end
+        end
+
         def on_defs_e(node)
           context.track! self
 
           replace(node.loc.assignment, "; ")
           insert_after(node.loc.expression, "; end")
 
+          new_loc = node.loc.dup
+          new_loc.instance_variable_set(:@end, node.loc.expression)
+
           process(
             node.updated(
               :defs,
-              node.children
+              node.children,
+              location: new_loc
             )
           )
         end

data/lib/ruby-next/language/rewriters/find_pattern.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "ruby-next/language/rewriters/pattern_matching"
+
+module RubyNext
+  module Language
+    module Rewriters
+      using RubyNext
+
+      # Separate pattern matching rewriter for Ruby 2.7 to
+      # transpile only case...in  with a find pattern
+      class FindPattern < PatternMatching
+        NAME = "pattern-matching-find-pattern"
+        SYNTAX_PROBE = "case 0; in [*,0,*]; true; else; 1; end"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.0.0")
+
+        def on_case_match(node)
+          @has_find_pattern = false
+          process_regular_node(node).then do |new_node|
+            return new_node unless has_find_pattern
+            super(node)
+          end
+        end
+
+        def on_in_match(node)
+          @has_find_pattern = false
+          process_regular_node(node).then do |new_node|
+            return new_node unless has_find_pattern
+            super(node)
+          end
+        end
+
+        def on_find_pattern(node)
+          @has_find_pattern = true
+          super(node)
+        end
+
+        private
+
+        attr_reader :has_find_pattern
+      end
+    end
+  end
+end

data/lib/ruby-next/language/rewriters/method_reference.rb

@@ -6,7 +6,7 @@ module RubyNext
       class MethodReference < Base
         NAME = "method-reference"
         SYNTAX_PROBE = "Language.:transform"
-        MIN_SUPPORTED_VERSION = Gem::Version.new("2.7.0")
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.0.0")
 
         def on_meth_ref(node)
           context.track! self

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

@@ -10,6 +10,16 @@ module RubyNext
           def to_ast_node
             self
           end
+
+          # Useful to generate simple operation nodes
+          # (e.g., 'a + b')
+          def -(val)
+            ::Parser::AST::Node.new(:send, [self, :-, val.to_ast_node])
+          end
+
+          def +(val)
+            ::Parser::AST::Node.new(:send, [self, :+, val.to_ast_node])
+          end
         end
 
         refine String do
@@ -249,7 +259,7 @@ module RubyNext
           rewrite_case_in! node, matchee_ast, case_clause
 
           node.updated(
-            :begin,
+            :kwbegin,
             [
               matchee_ast, case_clause
             ]
@@ -288,7 +298,7 @@ module RubyNext
               pattern
             ]
           ).tap do |new_node|
-            replace(node.loc.expression, new_node)
+            replace(node.loc.expression, inline_blocks(unparse(new_node)))
           end
         end
 
@@ -307,14 +317,14 @@ module RubyNext
                 body_indent = " " * clause.children[2].loc.column
                 replace(
                   clause.loc.expression,
-                  "when #{unparse(new_node.children[i].children[0])}" \
+                  "when #{inline_blocks(unparse(new_node.children[i].children[0]))}" \
                   "#{padding}" \
                   "#{body_indent}#{clause.children[2].loc.expression.source}"
                 )
               else
                 replace(
                   clause.loc.keyword.end.join(clause.children[0].loc.expression.end),
-                  new_node.children[i].children[0]
+                  inline_blocks(unparse(new_node.children[i].children[0]))
                 )
                 remove(clause.children[1].loc.expression) if clause.children[1]
                 replace(clause.loc.keyword, "when ")
@@ -430,6 +440,8 @@ module RubyNext
             right =
               if node.children.empty?
                 case_eq_clause(s(:array), s(:lvar, locals[:arr]))
+              elsif node.children.size > 1 && node.children.first.type == :match_rest && node.children.last.type == :match_rest
+                array_find(*node.children)
               else
                 array_element(0, *node.children)
               end
@@ -443,6 +455,7 @@ module RubyNext
         end
 
         alias array_pattern_with_tail_clause array_pattern_clause
+        alias find_pattern_clause array_pattern_clause
 
         def deconstruct_node(matchee)
           context.use_ruby_next!
@@ -478,9 +491,80 @@ module RubyNext
           end
         end
 
+        # [*a, 1, 2, *] -> arr.find.with_index { |_, i| (a = arr.take(i)) && arr[i] == 1 && arr[i + 1] == 2 }
+        def array_find(head, *nodes, tail)
+          index = s(:lvar, :__i__)
+
+          match_vars = []
+
+          head_match =
+            unless head.children.empty?
+              match_vars << s(:lvasgn, head.children[0].children[0])
+
+              arr_take = s(:send,
+                s(:lvar, locals[:arr]),
+                :take,
+                index)
+
+              match_var_clause(head.children[0], arr_take)
+            end
+
+          tail_match =
+            unless tail.children.empty?
+              match_vars << s(:lvasgn, tail.children[0].children[0])
+
+              match_var_clause(tail.children[0], arr_slice(index + nodes.size, -1))
+            end
+
+          nodes.each do |node|
+            if node.type == :match_var
+              match_vars << s(:lvasgn, node.children[0])
+            elsif node.type == :match_as
+              match_vars << s(:lvasgn, node.children[1].children[0])
+            end
+          end
+
+          pattern = array_rest_element(*nodes, index).then do |needle|
+            next needle unless head_match
+            s(:and,
+              needle,
+              head_match)
+          end.then do |headed_needle|
+            next headed_needle unless tail_match
+
+            s(:and,
+              headed_needle,
+              tail_match)
+          end
+
+          s(:block,
+            s(:send,
+              s(:send,
+                s(:lvar, locals[:arr]),
+                :find),
+              :with_index),
+            s(:args,
+              s(:arg, :_),
+              s(:arg, :__i__)),
+            pattern).then do |block|
+            next block if match_vars.empty?
+
+            # We need to declare match vars outside of `find` block
+            locals_declare = s(:masgn,
+              s(:mlhs, *match_vars),
+              s(:nil))
+
+            s(:or,
+              locals_declare,
+              block)
+          end
+        end
+
         def array_match_rest(index, node, *tail)
+          size = tail.size + 1
           child = node.children[0]
-          rest = arr_rest_items(index, tail.size).then do |r|
+
+          rest = arr_slice(index, -size).then do |r|
             next r unless child
 
             match_var_clause(
@@ -493,16 +577,16 @@ module RubyNext
 
           s(:and,
             rest,
-            array_rest_element(*tail))
+            array_rest_element(*tail, -(size - 1)))
         end
 
-        def array_rest_element(head, *tail)
-          send("#{head.type}_array_element", head, -(tail.size + 1)).then do |node|
+        def array_rest_element(head, *tail, index)
+          send("#{head.type}_array_element", head, index).then do |node|
             next node if tail.empty?
 
             s(:and,
               node,
-              array_rest_element(*tail))
+              array_rest_element(*tail, index + 1))
           end
         end
 
@@ -549,12 +633,12 @@ module RubyNext
           s(:index, arr, index.to_ast_node)
         end
 
-        def arr_rest_items(index, size, arr = s(:lvar, locals[:arr]))
+        def arr_slice(lindex, rindex, arr = s(:lvar, locals[:arr]))
           s(:index,
             arr,
             s(:irange,
-              s(:int, index),
-              s(:int, -(size + 1))))
+              lindex.to_ast_node,
+              rindex.to_ast_node))
         end
 
         #=========== ARRAY PATTERN (END) ===============
@@ -848,6 +932,12 @@ module RubyNext
 
           deconstructed_keys[key] = :"k#{deconstructed_keys.size}"
         end
+
+        # Unparser generates `do .. end`  blocks, we want to
+        # have single-line blocks with `{ ... }`.
+        def inline_blocks(source)
+          source.gsub(/do \|_, __i__\|\n\s*([^\n]+)\n\s*end/, '{ |_, __i__| \1 }')
+        end
       end
     end
   end

data/lib/ruby-next/language/rewriters/right_hand_assignment.rb

@@ -6,39 +6,101 @@ module RubyNext
       class RightHandAssignment < Base
         NAME = "right-hand-assignment"
         SYNTAX_PROBE = "1 + 2 => a"
-        MIN_SUPPORTED_VERSION = Gem::Version.new("2.8.0")
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.0.0")
 
         def on_rasgn(node)
           context.track! self
 
+          node = super(node)
+
           val_node, asgn_node = *node
 
           remove(val_node.loc.expression.end.join(asgn_node.loc.expression))
           insert_before(val_node.loc.expression, "#{asgn_node.loc.expression.source} = ")
 
-          process(
-            asgn_node.updated(
-              nil,
-              asgn_node.children + [val_node]
-            )
+          asgn_node.updated(
+            nil,
+            asgn_node.children + [val_node]
           )
         end
 
+        def on_vasgn(node)
+          return super(node) unless rightward?(node)
+
+          context.track! self
+
+          name, val_node = *node
+
+          remove(val_node.loc.expression.end.join(node.loc.name))
+          insert_before(val_node.loc.expression, "#{name} = ")
+
+          super(node)
+        end
+
+        def on_casgn(node)
+          return super(node) unless rightward?(node)
+
+          context.track! self
+
+          scope_node, name, val_node = *node
+
+          if scope_node
+            scope = scope_node.type == :cbase ? scope_node.loc.expression.source : "#{scope_node.loc.expression.source}::"
+            name = "#{scope}#{name}"
+          end
+
+          remove(val_node.loc.expression.end.join(node.loc.name))
+          insert_before(val_node.loc.expression, "#{name} = ")
+
+          super(node)
+        end
+
         def on_mrasgn(node)
           context.track! self
 
+          node = super(node)
+
           lhs, rhs = *node
 
           replace(lhs.loc.expression.end.join(rhs.loc.expression), ")")
           insert_before(lhs.loc.expression, "#{rhs.loc.expression.source} = (")
 
-          process(
-            node.updated(
-              :masgn,
-              [rhs, lhs]
-            )
+          node.updated(
+            :masgn,
+            [rhs, lhs]
           )
         end
+
+        def on_masgn(node)
+          return super(node) unless rightward?(node)
+
+          context.track! self
+
+          rhs, lhs = *node
+
+          replace(lhs.loc.expression.end.join(rhs.loc.expression), ")")
+          insert_before(lhs.loc.expression, "#{rhs.loc.expression.source} = (")
+
+          super(node)
+        end
+
+        private
+
+        def rightward?(node)
+          # Location could be empty for node built by rewriters
+          return false unless node.loc&.operator
+
+          assignee_loc =
+            if node.type == :masgn
+              node.children[0].loc.expression
+            else
+              node.loc.name
+            end
+
+          return false unless assignee_loc
+
+          assignee_loc.begin_pos > node.loc.operator.end_pos
+        end
       end
     end
   end

data/lib/ruby-next/language/rewriters/safe_navigation.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class SafeNavigation < Base
+        NAME = "safe-navigation"
+        SYNTAX_PROBE = "nil&.x&.nil?"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("2.3.0")
+
+        def on_csend(node)
+          node = super(node)
+
+          context.track! self
+
+          receiver, *args = *node
+
+          new_node = node.updated(
+            :and,
+            [
+              process(safe_navigation(receiver)),
+              s(:send, decsendize(receiver), *args)
+            ]
+          )
+
+          replace(node.loc.expression, new_node)
+
+          new_node
+        end
+
+        def on_block(node)
+          return super(node) unless node.children[0].type == :csend
+
+          context.track!(self)
+
+          new_node = super(node.updated(
+            :and,
+            [
+              process(safe_navigation(node.children[0].children[0])),
+              process(node.updated(nil, node.children.map(&method(:decsendize))))
+            ]
+          ))
+
+          replace(node.loc.expression, new_node)
+
+          new_node
+        end
+
+        def on_op_asgn(node)
+          return super(node) unless node.children[0].type == :csend
+
+          context.track!(self)
+
+          new_node = super(node.updated(
+            :and,
+            [
+              process(safe_navigation(node.children[0].children[0])),
+              process(node.updated(nil, node.children.map(&method(:decsendize))))
+            ]
+          ))
+
+          replace(node.loc.expression, new_node)
+
+          new_node
+        end
+
+        private
+
+        def decsendize(node)
+          return node unless node.is_a?(::Parser::AST::Node) && node.type == :csend
+
+          node.updated(:send, node.children.map(&method(:decsendize)))
+        end
+
+        # Transform: x&.y -> (!x.nil? && x.y) || nil
+        # This allows us to handle `false&.to_s == "false"`
+        def safe_navigation(node)
+          s(:or,
+            s(:send,
+              s(:send, node, :nil?),
+              :!),
+            s(:nil))
+        end
+      end
+    end
+  end
+end