ruby-next-core 0.9.2 → 0.10.0

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,7 +6,7 @@ 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

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

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class ShorthandHash < Base
+        NAME = "shorthand-hash"
+        SYNTAX_PROBE = "data = {x}"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.0.0")
+
+        def on_ipair(node)
+          context.track! self
+
+          ident, = *node.children
+
+          key = key_from_ident(ident)
+
+          replace(
+            node.loc.expression,
+            "#{key}: #{key}"
+          )
+
+          node.updated(
+            :pair,
+            [
+              s(:sym, key),
+              ident
+            ]
+          )
+        end
+
+        private
+
+        def key_from_ident(node)
+          case node.type
+          when :send
+            node.children[1]
+          when :lvar
+            node.children[0]
+          else
+            raise ArgumentError, "Unsupport ipair node: #{node}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class SquigglyHeredoc < Base
+        NAME = "squiggly-heredoc"
+        SYNTAX_PROBE = "txt = <<~TXT\n  bla\n      TXT"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("2.3.0")
+
+        def on_str(node)
+          node = super(node) if defined?(super_method)
+          return node unless node.loc.respond_to?(:heredoc_body) && node.loc.expression.source.include?("<<~")
+
+          context.track! self
+
+          replace(node.loc.expression, node.loc.expression.source.tr("~", "-"))
+
+          heredoc_loc = node.loc.heredoc_body.join(node.loc.heredoc_end)
+          heredoc_source, heredoc_end = heredoc_loc.source.split(/\n([^\n]+)\z/)
+
+          indent = heredoc_source.lines.map { |line| line.match(/^\s*/)[0].size }.min
+
+          new_source = heredoc_source.gsub!(%r{^\s{#{indent}}}, "")
+
+          replace(heredoc_loc, [new_source, heredoc_end].join("\n"))
+
+          node
+        end
+
+        alias on_dstr on_str
+        alias on_xstr on_str
+      end
+    end
+  end
+end

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

@@ -6,17 +6,3 @@ require "parser/current"
 $VERBOSE = save_verbose
 
 require "unparser"
-
-unless defined?(Unparser::UnknownEmitterError)
-  module Unparser
-    class UnknownEmitterError < ArgumentError
-    end
-
-    Emitter.singleton_class.prepend(Module.new do
-      def emitter(node, parent)
-        raise UnknownEmitterError, "No emitter for node: #{node.type.inspect}" unless Emitter::REGISTRY.key?(node.type)
-        super
-      end
-    end)
-  end
-end