ruby-next-core 0.9.0 → 0.10.2

data/lib/ruby-next/core/unboundmethod/bind_call.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 RubyNext::Core.patch UnboundMethod, method: :bind_call, version: "2.7" do
-  <<~'RUBY'
-    def bind_call(receiver, *args, &block)
-      bind(receiver).call(*args, &block)
-    end
+  <<-RUBY
+def bind_call(receiver, *args, &block)
+  bind(receiver).call(*args, &block)
+end
   RUBY
 end

data/lib/ruby-next/core_ext.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "core"
+require "ruby-next/core"
 
 # Monkey-patch core classes using the same patches as for refinements
 RubyNext::Core.patches.extensions.each do |mod, patches|

data/lib/ruby-next/language.rb

@@ -23,6 +23,8 @@ module RubyNext
     require "ruby-next/language/parser"
     require "ruby-next/language/unparser"
 
+    RewriterNotFoundError = Class.new(StandardError)
+
     class TransformContext
       attr_reader :versions, :use_ruby_next
 
@@ -85,12 +87,6 @@ module RubyNext
       def runtime!
         require "ruby-next/language/rewriters/runtime"
 
-        if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.7.0") && !defined?(Unparser::Emitter::CaseMatch)
-          RubyNext.warn "Ruby Next fallbacks to \"rewrite\" transpiling mode since Unparser doesn't support 2.7 AST yet.\n" \
-            "See https://github.com/mbj/unparser/pull/142"
-          self.mode = :rewrite
-        end
-
         @runtime = true
       end
 
@@ -104,6 +100,13 @@ module RubyNext
         else
           regenerate(*args, **kwargs)
         end
+      rescue Unparser::UnknownNodeError
+        if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.7.0")
+          RubyNext.warn "Ruby Next fallbacks to \"rewrite\" transpiling mode since Unparser doesn't support 2.7+ AST yet.\n" \
+            "See https://github.com/mbj/unparser/pull/142"
+          self.mode = :rewrite
+        end
+        rewrite(*args, **kwargs)
       end
 
       def regenerate(source, rewriters: self.rewriters, using: RubyNext::Core.refine?, context: TransformContext.new)
@@ -149,6 +152,16 @@ module RubyNext
         @current_rewriters ||= rewriters.select(&:unsupported_syntax?)
       end
 
+      # This method guarantees that rewriters will be returned in order they defined in Language module
+      def select_rewriters(*names)
+        rewriters_delta = names - rewriters.map { |rewriter| rewriter::NAME }
+        if rewriters_delta.any?
+          raise RewriterNotFoundError, "Rewriters not found: #{rewriters_delta.join(",")}"
+        end
+
+        rewriters.select { |rewriter| names.include?(rewriter::NAME) }
+      end
+
       private
 
       attr_writer :watch_dirs
@@ -160,6 +173,12 @@ module RubyNext
 
     require "ruby-next/language/rewriters/base"
 
+    require "ruby-next/language/rewriters/squiggly_heredoc"
+    rewriters << Rewriters::SquigglyHeredoc
+
+    require "ruby-next/language/rewriters/safe_navigation"
+    rewriters << Rewriters::SafeNavigation
+
     require "ruby-next/language/rewriters/args_forward"
     rewriters << Rewriters::ArgsForward
 
@@ -169,6 +188,11 @@ module RubyNext
     require "ruby-next/language/rewriters/pattern_matching"
     rewriters << Rewriters::PatternMatching
 
+    # Must be added after general pattern matching rewriter to become
+    # no-op in Ruby <2.7
+    require "ruby-next/language/rewriters/find_pattern"
+    rewriters << Rewriters::FindPattern
+
     # Put endless range in the end, 'cause Parser fails to parse it in
     # pattern matching
     require "ruby-next/language/rewriters/endless_range"

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

@@ -4,3 +4,6 @@
 
 require "ruby-next/language/rewriters/method_reference"
 RubyNext::Language.rewriters << RubyNext::Language::Rewriters::MethodReference
+
+require "ruby-next/language/rewriters/shorthand_hash"
+RubyNext::Language.rewriters << RubyNext::Language::Rewriters::ShorthandHash

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

@@ -4,16 +4,19 @@ module RubyNext
   module Language
     module Rewriters
       class ArgsForward < Base
-        SYNTAX_PROBE = "obj = Object.new; def obj.foo(...) super(...); end"
-        MIN_SUPPORTED_VERSION = Gem::Version.new("2.7.0")
+        NAME = "args-forward"
+        SYNTAX_PROBE = "obj = Object.new; def obj.foo(...) super(1, ...); end"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.0.0")
 
         REST = :__rest__
         BLOCK = :__block__
 
-        def on_forward_args(node)
+        def on_forward_arg(node)
           context.track! self
 
-          replace(node.loc.expression, "(*#{REST}, &#{BLOCK})")
+          node = super(node)
+
+          replace(node.loc.expression, "*#{REST}, &#{BLOCK}")
 
           node.updated(
             :args,
@@ -25,34 +28,35 @@ module RubyNext
         end
 
         def on_send(node)
-          return super(node) unless node.children[2]&.type == :forwarded_args
+          fargs = node.children.find { |child| child.is_a?(::Parser::AST::Node) && child.type == :forwarded_args }
+          return super(node) unless fargs
+
+          process_fargs(node, fargs)
+        end
+
+        def on_super(node)
+          fargs = node.children.find { |child| child.is_a?(::Parser::AST::Node) && child.type == :forwarded_args }
+          return super(node) unless fargs
+
+          process_fargs(node, fargs)
+        end
+
+        private
 
-          replace(node.children[2].loc.expression, "*#{REST}, &#{BLOCK}")
+        def process_fargs(node, fargs)
+          replace(fargs.loc.expression, "*#{REST}, &#{BLOCK}")
 
           process(
             node.updated(
               nil,
               [
-                *node.children[0..1],
+                *node.children.take(node.children.index(fargs)),
                 *forwarded_args
               ]
             )
           )
         end
 
-        def on_super(node)
-          return super(node) unless node.children[0]&.type == :forwarded_args
-
-          replace(node.children[0].loc.expression, "*#{REST}, &#{BLOCK}")
-
-          node.updated(
-            nil,
-            forwarded_args
-          )
-        end
-
-        private
-
         def forwarded_args
           [
             s(:splat, s(:lvar, REST)),

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

@@ -4,8 +4,16 @@ module RubyNext
   module Language
     module Rewriters
       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
@@ -13,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/endless_range.rb

@@ -4,6 +4,7 @@ module RubyNext
   module Language
     module Rewriters
       class EndlessRange < Base
+        NAME = "endless-range"
         SYNTAX_PROBE = "[0, 1][1..]"
         MIN_SUPPORTED_VERSION = Gem::Version.new("2.6.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

@@ -4,8 +4,9 @@ module RubyNext
   module Language
     module Rewriters
       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/numbered_params.rb

@@ -6,6 +6,7 @@ module RubyNext
       class NumberedParams < Base
         using RubyNext
 
+        NAME = "numbered-params"
         SYNTAX_PROBE = "proc { _1 }.call(1)"
         MIN_SUPPORTED_VERSION = Gem::Version.new("2.7.0")
 

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
@@ -216,6 +226,7 @@ module RubyNext
       end
 
       class PatternMatching < Base
+        NAME = "pattern-matching"
         SYNTAX_PROBE = "case 0; in 0; true; else; 1; end"
         MIN_SUPPORTED_VERSION = Gem::Version.new("2.7.0")
 
@@ -248,7 +259,7 @@ module RubyNext
           rewrite_case_in! node, matchee_ast, case_clause
 
           node.updated(
-            :begin,
+            :kwbegin,
             [
               matchee_ast, case_clause
             ]
@@ -287,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
 
@@ -306,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 ")
@@ -429,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
@@ -442,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!
@@ -477,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(
@@ -492,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
 
@@ -548,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) ===============
@@ -847,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