ruby-next-core 0.14.0 → 1.0.1

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

@@ -182,7 +182,6 @@ module RubyNext
           end
         end
 
-        # rubocop:disable Style/MethodMissingSuper
         # rubocop:disable Style/MissingRespondToMissing
         class Noop < Base
           # Return node itself, no memoization
@@ -243,6 +242,7 @@ module RubyNext
 
           @deconstructed_keys = {}
           @predicates = Predicates::CaseIn.new
+          @lvars = []
 
           matchee_ast =
             s(:begin, s(:lvasgn, MATCHEE, node.children[0]))
@@ -272,6 +272,7 @@ module RubyNext
 
           @deconstructed_keys = {}
           @predicates = Predicates::Noop.new
+          @lvars = []
 
           matchee =
             s(:begin, s(:lvasgn, MATCHEE, node.children[0]))
@@ -282,10 +283,12 @@ module RubyNext
               arr: MATCHEE_ARR,
               hash: MATCHEE_HASH
             ) do
-              send(
-                :"#{node.children[1].type}_clause",
-                node.children[1]
-              ).then do |node|
+              with_declared_locals do
+                send(
+                  :"#{node.children[1].type}_clause",
+                  node.children[1]
+                )
+              end.then do |node|
                 s(:begin,
                   s(:or,
                     node,
@@ -311,6 +314,7 @@ module RubyNext
 
           @deconstructed_keys = {}
           @predicates = Predicates::Noop.new
+          @lvars = []
 
           matchee =
             s(:begin, s(:lvasgn, MATCHEE, node.children[0]))
@@ -321,10 +325,12 @@ module RubyNext
               arr: MATCHEE_ARR,
               hash: MATCHEE_HASH
             ) do
-              send(
-                :"#{node.children[1].type}_clause",
-                node.children[1]
-              )
+              with_declared_locals do
+                send(
+                  :"#{node.children[1].type}_clause",
+                  node.children[1]
+                )
+              end
             end
 
           node.updated(
@@ -395,13 +401,15 @@ module RubyNext
         def build_when_clause(clause)
           predicates.reset!
           [
-            with_guard(
-              send(
-                :"#{clause.children[0].type}_clause",
-                clause.children[0]
-              ),
-              clause.children[1] # guard
-            ),
+            with_declared_locals do
+              with_guard(
+                send(
+                  :"#{clause.children[0].type}_clause",
+                  clause.children[0]
+                ),
+                clause.children[1] # guard
+              )
+            end,
             process(clause.children[2] || s(:nil)) # expression
           ].then do |children|
             s(:when, *children)
@@ -417,15 +425,15 @@ module RubyNext
             s(:begin,
               s(:and,
                 node,
-                send(:"#{pattern.type}_clause", pattern)))
+                send(:"#{pattern.type}_clause", pattern, right)))
           end
         end
 
-        def match_alt_clause(node)
+        def match_alt_clause(node, matchee = s(:lvar, locals[:matchee]))
           children = locals.with(ALTERNATION_MARKER => true) do
             node.children.map.with_index do |child, i|
               predicates.terminate! if i == 1
-              send :"#{child.type}_clause", child
+              send :"#{child.type}_clause", child, matchee
             end
           end
           s(:begin, s(:or, *children))
@@ -442,7 +450,7 @@ module RubyNext
           var = node.children[0]
           return s(:true) if var == :_
 
-          check_match_var_alternation!(var) unless var.is_a?(::Parser::AST::Node)
+          check_match_var_alternation!(var)
 
           s(:begin,
             s(:or,
@@ -541,11 +549,10 @@ module RubyNext
         def array_find(head, *nodes, tail)
           index = s(:lvar, :__i__)
 
-          match_vars = []
-
           head_match =
             unless head.children.empty?
-              match_vars << build_var_assignment(head.children[0].children[0])
+              # we only need to call this to track the lvar usage
+              build_var_assignment(head.children[0].children[0])
 
               arr_take = s(:send,
                 s(:lvar, locals[:arr]),
@@ -557,16 +564,19 @@ module RubyNext
 
           tail_match =
             unless tail.children.empty?
-              match_vars << build_var_assignment(tail.children[0].children[0])
+              # we only need to call this to track the lvar usage
+              build_var_assignment(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 << build_var_assignment(node.children[0])
+              # we only need to call this to track the lvar usage
+              build_var_assignment(node.children[0])
             elsif node.type == :match_as
-              match_vars << build_var_assignment(node.children[1].children[0])
+              # we only need to call this to track the lvar usage
+              build_var_assignment(node.children[1].children[0])
             end
           end
 
@@ -594,19 +604,7 @@ module RubyNext
             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(:begin, s(:masgn,
-              s(:mlhs, *match_vars),
-              s(:nil)))
-
-            s(:begin,
-              s(:or,
-                locals_declare,
-                block))
-          end
+            pattern)
         end
 
         def array_match_rest(index, node, *tail)
@@ -649,6 +647,14 @@ module RubyNext
           end
         end
 
+        def find_pattern_array_element(node, index)
+          element = arr_item_at(index)
+          locals.with(arr: locals[:arr, index]) do
+            predicates.push :"i#{index}"
+            find_pattern_clause(node, element).tap { predicates.pop }
+          end
+        end
+
         def hash_pattern_array_element(node, index)
           element = arr_item_at(index)
           locals.with(hash: locals[:arr, index]) do
@@ -657,6 +663,14 @@ module RubyNext
           end
         end
 
+        def const_pattern_array_element(node, index)
+          element = arr_item_at(index)
+          locals.with(arr: locals[:arr, index]) do
+            predicates.push :"i#{index}"
+            const_pattern_clause(node, element).tap { predicates.pop }
+          end
+        end
+
         def match_alt_array_element(node, index)
           children = node.children.map do |child, i|
             send :"#{child.type}_array_element", child, index
@@ -665,11 +679,19 @@ module RubyNext
         end
 
         def match_var_array_element(node, index)
-          match_var_clause(node, arr_item_at(index))
+          element = arr_item_at(index)
+          locals.with(arr: locals[:arr, index]) do
+            predicates.push :"i#{index}"
+            match_var_clause(node, element).tap { predicates.pop }
+          end
         end
 
         def match_as_array_element(node, index)
-          match_as_clause(node, arr_item_at(index))
+          element = arr_item_at(index)
+          locals.with(arr: locals[:arr, index]) do
+            predicates.push :"i#{index}"
+            match_as_clause(node, element).tap { predicates.pop }
+          end
         end
 
         def pin_array_element(node, index)
@@ -829,6 +851,24 @@ module RubyNext
           end
         end
 
+        def find_pattern_hash_element(node, key)
+          element = hash_value_at(key)
+          key_index = deconstructed_key(key)
+          locals.with(arr: locals[:hash, key_index]) do
+            predicates.push :"k#{key_index}"
+            find_pattern_clause(node, element).tap { predicates.pop }
+          end
+        end
+
+        def const_pattern_hash_element(node, key)
+          element = hash_value_at(key)
+          key_index = deconstructed_key(key)
+          locals.with(hash: locals[:hash, key_index]) do
+            predicates.push :"k#{key_index}"
+            const_pattern_clause(node, element).tap { predicates.pop }
+          end
+        end
+
         def hash_element(head, *tail)
           send("#{head.type}_hash_element", head).then do |node|
             next node if tail.empty?
@@ -869,12 +909,22 @@ module RubyNext
         end
 
         def match_as_hash_element(node, key)
-          match_as_clause(node, hash_value_at(key))
+          element = hash_value_at(key)
+          key_index = deconstructed_key(key)
+          locals.with(hash: locals[:hash, key_index]) do
+            predicates.push :"k#{key_index}"
+            match_as_clause(node, element).tap { predicates.pop }
+          end
         end
 
         def match_var_hash_element(node, key = nil)
           key ||= node.children[0]
-          match_var_clause(node, hash_value_at(key))
+          element = hash_value_at(key)
+          key_index = deconstructed_key(key)
+          locals.with(hash: locals[:hash, key_index]) do
+            predicates.push :"k#{key_index}"
+            match_var_clause(node, element).tap { predicates.pop }
+          end
         end
 
         def match_nil_pattern_hash_element(node, _key = nil)
@@ -948,6 +998,24 @@ module RubyNext
           end
         end
 
+        def with_declared_locals
+          lvars.clear
+          node = yield
+
+          return node if lvars.empty?
+
+          # We need to declare match lvars outside of the outer `find` block,
+          # so we do that for that whole pattern
+          locals_declare = s(:begin, s(:masgn,
+            s(:mlhs, *lvars.uniq.map { s(:lvasgn, _1) }),
+            s(:nil)))
+
+          s(:begin,
+            s(:or,
+              locals_declare,
+              node))
+        end
+
         def no_matching_pattern
           raise_error(
             :NoMatchingPatternError,
@@ -982,13 +1050,17 @@ module RubyNext
 
         private
 
-        attr_reader :deconstructed_keys, :predicates
+        attr_reader :deconstructed_keys, :predicates, :lvars
 
         # Raise SyntaxError if match-var is used within alternation
         # https://github.com/ruby/ruby/blob/672213ef1ca2b71312084057e27580b340438796/compile.c#L5900
         def check_match_var_alternation!(name)
           return unless locals.key?(ALTERNATION_MARKER)
 
+          if name.is_a?(::Parser::AST::Node)
+            raise ::SyntaxError, "illegal variable in alternative pattern (#{name.children.first})"
+          end
+
           return if name.start_with?("_")
 
           raise ::SyntaxError, "illegal variable in alternative pattern (#{name})"
@@ -1008,7 +1080,10 @@ module RubyNext
 
         # Value could be omitted for mass assignment
         def build_var_assignment(var, value = nil)
-          return s(:lvasgn, *[var, value].compact) unless var.is_a?(::Parser::AST::Node)
+          unless var.is_a?(::Parser::AST::Node)
+            lvars << var
+            return s(:lvasgn, *[var, value].compact)
+          end
 
           asign_type = :"#{var.type.to_s[0]}vasgn"
 

data/lib/ruby-next/language/rewriters/3.0/args_forward_leading.rb

@@ -50,7 +50,7 @@ module RubyNext
 
           return false unless fargs
 
-          node.children.index(fargs) > (node.type == :send ? 2 : 0)
+          node.children.index(fargs) > ((node.type == :send) ? 2 : 0)
         end
 
         def method_with_leading_arg(node)
@@ -62,7 +62,7 @@ module RubyNext
         end
 
         def def_with_leading_farg(node)
-          args = node.type == :defs ? node.children[2] : node.children[1]
+          args = (node.type == :defs) ? node.children[2] : node.children[1]
           args = args.children
 
           farg = args.detect { |child| child.type == :forward_arg }

data/lib/ruby-next/language/rewriters/3.1/oneline_pattern_parensless.rb

@@ -25,7 +25,7 @@ module RubyNext
 
             context.track! self
 
-            left_p, right_p = pattern.type == :array_pattern ? %w([ ]) : %w[{ }]
+            left_p, right_p = (pattern.type == :array_pattern) ? %w([ ]) : %w[{ }]
 
             insert_before(pattern.loc.expression, left_p)
             insert_after(pattern.loc.expression, right_p)

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

@@ -9,7 +9,8 @@ module RubyNext
         MIN_SUPPORTED_VERSION = Gem::Version.new("3.1.0")
 
         def on_pair(node)
-          return super(node) unless node.children[0].loc.last_column == node.children[1].loc.last_column
+          return super(node) unless (node.children[0].loc.last_column == node.children[1].loc.last_column) &&
+            (node.children[1].loc.first_line == node.children[1].loc.last_line)
 
           context.track! self
 

data/lib/ruby-next/language/rewriters/3.2/anonymous_restargs.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class AnonymousRestArgs < Base
+        NAME = "anonymous-rest-args"
+        SYNTAX_PROBE = "obj = Object.new; def obj.foo(*) bar(*); end"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.2.0")
+
+        REST = :__rest__
+        KWREST = :__kwrest__
+
+        def on_args(node)
+          rest = node.children.find { |child| child.is_a?(::Parser::AST::Node) && child.type == :restarg && child.children.first.nil? }
+          kwrest = node.children.find { |child| child.is_a?(::Parser::AST::Node) && child.type == :kwrestarg && child.children.first.nil? }
+
+          return super unless rest || kwrest
+
+          context.track! self
+
+          replace(rest.loc.expression, "*#{REST}") if rest
+          replace(kwrest.loc.expression, "**#{KWREST}") if kwrest
+
+          new_args = node.children.map do |child|
+            if child == rest
+              s(:restarg, REST)
+            elsif child == kwrest
+              s(:kwrestarg, KWREST)
+            else
+              child
+            end
+          end
+
+          node.updated(:args, new_args)
+        end
+
+        def on_send(node)
+          return super unless forwarded_args?(node)
+
+          process_send_args(node)
+        end
+
+        def on_super(node)
+          return super unless forwarded_args?(node)
+
+          process_send_args(node)
+        end
+
+        private
+
+        def forwarded_args?(node)
+          node.children.each do |child|
+            next unless child.is_a?(::Parser::AST::Node)
+
+            if child.type == :forwarded_restarg
+              return true
+            elsif child.type == :kwargs
+              child.children.each do |kwarg|
+                next unless kwarg.is_a?(::Parser::AST::Node)
+
+                return true if kwarg.type == :forwarded_kwrestarg
+              end
+            end
+          end
+
+          false
+        end
+
+        def process_send_args(node)
+          process(
+            node.updated(
+              nil,
+              node.children.map do |child|
+                next child unless child.is_a?(::Parser::AST::Node)
+
+                if child.type == :forwarded_restarg
+                  replace(child.loc.expression, "*#{REST}")
+                  s(:ksplat, s(:lvar, REST))
+                elsif child.type == :kwargs
+                  child.updated(
+                    nil,
+                    child.children.map do |kwarg|
+                      next kwarg unless kwarg.is_a?(::Parser::AST::Node)
+
+                      if kwarg.type == :forwarded_kwrestarg
+                        replace(kwarg.loc.expression, "**#{KWREST}")
+                        s(:kwsplat, s(:lvar, KWREST))
+                      else
+                        kwarg
+                      end
+                    end
+                  )
+                else
+                  child
+                end
+              end
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class Abstract < ::Parser::TreeRewriter
+        NAME = "custom-rewriter"
+        SYNTAX_PROBE = "1 = [}"
+        MIN_SUPPORTED_VERSION = Gem::Version.new(RubyNext::NEXT_VERSION)
+
+        class << self
+          # Returns true if the syntax is not supported
+          # by the current Ruby (performs syntax check, not version check)
+          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, nil, __FILE__, __LINE__
+            false
+          rescue SyntaxError, StandardError
+            true
+          ensure
+            $VERBOSE = save_verbose
+          end
+
+          # Returns true if the syntax is supported
+          # by the specified version
+          def unsupported_version?(version)
+            version < self::MIN_SUPPORTED_VERSION
+          end
+
+          def text?
+            false
+          end
+
+          def ast?
+            false
+          end
+
+          private
+
+          def transform(source)
+            Language.transform(source, rewriters: [self], using: false)
+          end
+        end
+
+        def initialize(context)
+          @context = context
+          super()
+        end
+
+        private
+
+        attr_reader :context
+      end
+    end
+  end
+end

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

@@ -13,7 +13,7 @@ module RubyNext
 
       MSG
 
-      class Base < ::Parser::TreeRewriter
+      class Base < Abstract
         class LocalsTracker
           using(Module.new do
             refine ::Parser::AST::Node do
@@ -65,39 +65,15 @@ module RubyNext
           end
         end
 
-        class << self
-          # Returns true if the syntax is supported
-          # by the current Ruby (performs syntax check, not version check)
-          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, nil, __FILE__, __LINE__
-            false
-          rescue SyntaxError, StandardError
-            true
-          ensure
-            $VERBOSE = save_verbose
-          end
-
-          # Returns true if the syntax is supported
-          # by the specified version
-          def unsupported_version?(version)
-            self::MIN_SUPPORTED_VERSION > version
-          end
-
-          private
+        attr_reader :locals
 
-          def transform(source)
-            Language.transform(source, rewriters: [self], using: false)
-          end
+        def self.ast?
+          true
         end
 
-        attr_reader :locals
-
-        def initialize(context)
-          @context = context
+        def initialize(*args)
           @locals = LocalsTracker.new
-          super()
+          super
         end
 
         def s(type, *children)
@@ -145,8 +121,6 @@ module RubyNext
 
           Unparser.unparse(ast).chomp
         end
-
-        attr_reader :context
       end
     end
   end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class ItParam < Base
+        using RubyNext
+
+        NAME = "it-param"
+        SYNTAX_PROBE = "proc { it.keys }.call({})"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.4.0")
+
+        def on_block(node)
+          proc_or_lambda, args, body = *node.children
+
+          return super unless block_has_it?(body)
+
+          context.track! self
+
+          new_body = s(:begin,
+            s(:lvasgn, :it, s(:lvar, :_1)),
+            body)
+
+          insert_before(body.loc.expression, "it = _1;")
+
+          process(
+            node.updated(:numblock, [
+              proc_or_lambda,
+              args,
+              new_body
+            ])
+          )
+        end
+
+        private
+
+        # It's important to check if the current block refers to `it` variable somewhere
+        # (and not within a nested block), so we don't declare numbered params
+        def block_has_it?(node)
+          # traverse node children deeply
+          tree = [node]
+
+          while (child = tree.shift)
+            return true if it?(child)
+
+            if child.is_a?(Parser::AST::Node)
+              tree.unshift(*child.children.select { |c| c.is_a?(Parser::AST::Node) && c.type != :block && c.type != :numblock })
+            end
+          end
+        end
+
+        def it?(node)
+          node.is_a?(Parser::AST::Node) && node.type == :send && node.children[0].nil? && node.children[1] == :it && node.children[2].nil?
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,15 @@
 # frozen_string_literal: true
 
 # Load edge Ruby features
+
+require "ruby-next/language/rewriters/edge/it_param"
+
+# We must add this rewriter before nubmered params rewriter to allow it to transform the source code further
+
+number_params = RubyNext::Language.rewriters.index(RubyNext::Language::Rewriters::NumberedParams)
+
+if number_params
+  RubyNext::Language.rewriters.insert(number_params, RubyNext::Language::Rewriters::ItParam)
+else
+  RubyNext::Language.rewriters << RubyNext::Language::Rewriters::ItParam
+end

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

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require "parser/rubynext"
+RubyNext::Language.parser_class = ::Parser::RubyNext
+
 module RubyNext
   module Language
     module Rewriters