ruby-next-core 0.8.0 → 0.10.0

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

@@ -3,14 +3,16 @@
 module RubyNext
   module Language
     module KernelEval
-      refine Kernel do
-        def eval(source, bind = nil, *args)
-          new_source = ::RubyNext::Language::Runtime.transform(
-            source,
-            using: bind&.receiver == TOPLEVEL_BINDING.receiver || bind&.receiver&.is_a?(Module)
-          )
-          RubyNext.debug_source(new_source, "(#{caller_locations(1, 1).first})")
-          super new_source, bind, *args
+      if Utils.refine_modules?
+        refine Kernel do
+          def eval(source, bind = nil, *args)
+            new_source = ::RubyNext::Language::Runtime.transform(
+              source,
+              using: bind&.receiver == TOPLEVEL_BINDING.receiver || bind&.receiver&.is_a?(Module)
+            )
+            RubyNext.debug_source(new_source, "(#{caller_locations(1, 1).first})")
+            super new_source, bind, *args
+          end
         end
       end
     end

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("2.7.2")
 
         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)
@@ -59,7 +59,7 @@ module RubyNext
           def unsupported_syntax?
             save_verbose, $VERBOSE = $VERBOSE, nil
             eval_mid = Kernel.respond_to?(:eval_without_ruby_next) ? :eval_without_ruby_next : :eval
-            Kernel.send eval_mid, self::SYNTAX_PROBE
+            Kernel.send eval_mid, self::SYNTAX_PROBE, nil, __FILE__, __LINE__
             false
           rescue SyntaxError, NameError
             true

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) ===============
@@ -816,11 +901,12 @@ module RubyNext
         end
 
         def respond_to_missing?(mid, *)
-          return true if mid.match?(/_(clause|array_element)/)
+          return true if mid.to_s.match?(/_(clause|array_element)/)
           super
         end
 
         def method_missing(mid, *args, &block)
+          mid = mid.to_s
           return case_eq_clause(*args) if mid.match?(/_clause$/)
           return case_eq_array_element(*args) if mid.match?(/_array_element$/)
           return case_eq_hash_element(*args) if mid.match?(/_hash_element$/)
@@ -846,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