ruby-next-core 0.13.1 → 0.14.1

data/lib/ruby-next/commands/nextify.rb

@@ -48,11 +48,11 @@ module RubyNext
           end
 
           opts.on("--edge", "Enable edge (master) Ruby features") do |val|
-            require "ruby-next/language/edge"
+            require "ruby-next/language/rewriters/edge"
           end
 
           opts.on("--proposed", "Enable proposed/experimental Ruby features") do |val|
-            require "ruby-next/language/proposed"
+            require "ruby-next/language/rewriters/proposed"
           end
 
           opts.on(

data/lib/ruby-next/config.rb

@@ -10,10 +10,10 @@ module RubyNext
   # Defines last minor version for every major version
   LAST_MINOR_VERSIONS = {
     2 => 8, # 2.8 is required for backward compatibility: some gems already uses it
-    3 => 0
+    3 => 1
   }.freeze
 
-  LATEST_VERSION = [3, 0].freeze
+  LATEST_VERSION = [3, 1].freeze
 
   # A virtual version number used for proposed features
   NEXT_VERSION = "1995.next.0"

data/lib/ruby-next/core/enumerable/compact.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+RubyNext::Core.patch Enumerable, method: :compact, version: "3.1" do
+  <<-RUBY
+def compact
+  reduce([]) do |acc, val|
+    acc << val unless val.nil?
+    acc
+  end
+end
+  RUBY
+end
+
+RubyNext::Core.patch Enumerator::Lazy, method: :compact, version: "3.1" do
+  <<-RUBY
+def compact
+  Enumerator::Lazy.new(self) do |yielder, value|
+    yielder << value unless value.nil?
+  end
+end
+  RUBY
+end

data/lib/ruby-next/core/integer/try_convert.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+RubyNext::Core.patch Integer.singleton_class, method: :try_convert, singleton: Integer, version: "3.1" do
+  <<-'RUBY'
+def try_convert(val)
+  return val if val.is_a?(Integer)
+
+  if val.respond_to?(:to_int)
+    val.to_int.tap do |res|
+      next if res.is_a?(Integer) || res.nil?
+      raise TypeError, "Can't convert #{res.class} to Integer"
+    end
+  end
+end
+  RUBY
+end

data/lib/ruby-next/core/matchdata/match.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RubyNext::Core.patch MatchData, method: :match, version: "3.1" do
+  <<-RUBY
+def match(index_or_name)
+  self[index_or_name]
+end
+  RUBY
+end

data/lib/ruby-next/core/refinement/import.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# We cannot use refinements here, since Ruby 2.6- doesn't support them in refine modules.
+# So, we use a defined method instead (and transpile source code to use it).
+# NOTE: We have to transpile the source code anyway, since we need to pass a binding.
+RubyNext::Core.singleton_class.module_eval do
+  def import_methods(other, bind)
+    import = []
+
+    other.instance_methods(false).each do |mid|
+      # check for non-Ruby methods
+      meth = other.instance_method(mid)
+      location = meth.source_location
+
+      if location.nil? || location.first.match?(/(<internal:|resource:\/truffleruby\/core)/)
+        raise ArgumentError, "Can't import method: #{other}##{mid} from #{location}"
+      end
+
+      source_file, lineno = *location
+
+      raise ArgumentError, "Can't import dynamicly added methods: #{other}##{mid}" unless File.file?(source_file)
+
+      lines = File.open(source_file).readlines
+
+      buffer = []
+
+      lines[(lineno - 1)..-1].each do |line|
+        buffer << line + "\n"
+
+        begin
+          if defined?(::RubyNext::Language) && ::RubyNext::Language.runtime?
+            new_source = ::RubyNext::Language.transform(buffer.join, rewriters: RubyNext::Language.current_rewriters, using: false)
+            # Transformed successfully => valid method => evaluate transpiled code
+            import << [new_source, source_file, lineno]
+            buffer.clear
+            break
+          end
+
+          # Borrowed from https://github.com/banister/method_source/blob/81d039c966ffd95d26e12eb2e205c0eb8377f49d/lib/method_source/code_helpers.rb#L66
+          catch(:valid) do
+            eval("BEGIN{throw :valid}\nObject.new.instance_eval { #{buffer.join} }") # rubocop:disable all
+          end
+          break
+        rescue SyntaxError
+        end
+      end
+
+      import << [buffer.join, source_file, lineno] unless buffer.empty?
+    end
+
+    import.each do |(definition, file, lino)|
+      Kernel.eval definition, bind, file, lino
+    end
+
+    # Copy constants (they could be accessed from methods)
+    other.constants.each do |name|
+      Kernel.eval "#{name} = #{other}::#{name}", bind
+    end
+  end
+end

data/lib/ruby-next/core.rb

@@ -62,7 +62,7 @@ module RubyNext
         mod_name = singleton? ? singleton.name : mod.name
         camelized_method_name = method_name.to_s.split("_").map(&:capitalize).join
 
-        "#{mod_name}#{camelized_method_name}".gsub(/\W/, "")
+        "#{mod_name}#{camelized_method_name}".gsub(/\W/, "") # rubocop:disable Performance/StringReplacement
       end
 
       def build_location(trace_locations)
@@ -173,6 +173,8 @@ require "ruby-next/core/unboundmethod/bind_call"
 require "ruby-next/core/time/floor"
 require "ruby-next/core/time/ceil"
 
+require "ruby-next/core/refinement/import"
+
 # Core extensions required for pattern matching
 # Required for pattern matching with refinements
 unless defined?(NoMatchingPatternError)
@@ -191,6 +193,10 @@ require "ruby-next/core/hash/except"
 
 require "ruby-next/core/array/intersect"
 
+require "ruby-next/core/matchdata/match"
+require "ruby-next/core/enumerable/compact"
+require "ruby-next/core/integer/try_convert"
+
 # Generate refinements
 RubyNext.module_eval do
   RubyNext::Core.patches.refined.each do |mod, patches|

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

@@ -37,6 +37,7 @@ module RubyNext
 
           source = args.shift
           new_source = ::RubyNext::Language::Runtime.transform(source, using: false)
+
           RubyNext.debug_source(new_source, "(#{caller_locations(1, 1).first})")
           super new_source, *args
         end

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

@@ -243,6 +243,7 @@ module RubyNext
 
           @deconstructed_keys = {}
           @predicates = Predicates::CaseIn.new
+          @lvars = []
 
           matchee_ast =
             s(:begin, s(:lvasgn, MATCHEE, node.children[0]))
@@ -272,6 +273,7 @@ module RubyNext
 
           @deconstructed_keys = {}
           @predicates = Predicates::Noop.new
+          @lvars = []
 
           matchee =
             s(:begin, s(:lvasgn, MATCHEE, node.children[0]))
@@ -282,10 +284,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,
@@ -306,6 +310,41 @@ module RubyNext
 
         alias on_in_match on_match_pattern
 
+        def on_match_pattern_p(node)
+          context.track! self
+
+          @deconstructed_keys = {}
+          @predicates = Predicates::Noop.new
+          @lvars = []
+
+          matchee =
+            s(:begin, s(:lvasgn, MATCHEE, node.children[0]))
+
+          pattern =
+            locals.with(
+              matchee: MATCHEE,
+              arr: MATCHEE_ARR,
+              hash: MATCHEE_HASH
+            ) do
+              with_declared_locals do
+                send(
+                  :"#{node.children[1].type}_clause",
+                  node.children[1]
+                )
+              end
+            end
+
+          node.updated(
+            :and,
+            [
+              matchee,
+              pattern
+            ]
+          ).tap do |new_node|
+            replace(node.loc.expression, inline_blocks(unparse(new_node)))
+          end
+        end
+
         private
 
         def rewrite_case_in!(node, matchee, new_node)
@@ -363,13 +402,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)
@@ -407,13 +448,14 @@ module RubyNext
         end
 
         def match_var_clause(node, left = s(:lvar, locals[:matchee]))
-          return s(:true) if node.children[0] == :_
+          var = node.children[0]
+          return s(:true) if var == :_
 
-          check_match_var_alternation! node.children[0]
+          check_match_var_alternation!(var)
 
           s(:begin,
             s(:or,
-              s(:begin, s(:lvasgn, node.children[0], left)),
+              s(:begin, build_var_assignment(var, left)),
               s(:true)))
         end
 
@@ -508,11 +550,10 @@ module RubyNext
         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])
+              # 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]),
@@ -524,16 +565,19 @@ module RubyNext
 
           tail_match =
             unless tail.children.empty?
-              match_vars << s(:lvasgn, 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 << s(:lvasgn, 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 << s(:lvasgn, 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
 
@@ -561,19 +605,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)
@@ -616,6 +648,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
@@ -796,6 +836,15 @@ 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 hash_element(head, *tail)
           send("#{head.type}_hash_element", head).then do |node|
             next node if tail.empty?
@@ -861,6 +910,10 @@ module RubyNext
           match_var_clause(child, s(:lvar, locals[:hash]))
         end
 
+        def pin_hash_element(node, index)
+          case_eq_hash_element node.children[0], index
+        end
+
         def case_eq_hash_element(node, key)
           case_eq_clause node, hash_value_at(key)
         end
@@ -911,6 +964,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,
@@ -945,13 +1016,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})"
@@ -968,6 +1043,18 @@ module RubyNext
         def inline_blocks(source)
           source.gsub(/(?:do|{) \|_, __i__\|\n\s*([^\n]+)\n\s*(?:end|})/, '{ |_, __i__| \1 }')
         end
+
+        # Value could be omitted for mass assignment
+        def build_var_assignment(var, value = nil)
+          unless var.is_a?(::Parser::AST::Node)
+            lvars << var
+            return s(:lvasgn, *[var, value].compact)
+          end
+
+          asign_type = :"#{var.type.to_s[0]}vasgn"
+
+          s(asign_type, *[var.children[0], value].compact)
+        end
       end
     end
   end

data/lib/ruby-next/language/rewriters/{endless_method.rb → 3.0/endless_method.rb}

@@ -8,14 +8,13 @@ module RubyNext
         SYNTAX_PROBE = "obj = Object.new; def obj.foo() = 42"
         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
+        def on_def(node)
+          return process_def(node) if endless?(node)
+
+          super(node)
         end
 
-        def on_def_e(node)
+        def process_def(node)
           context.track! self
 
           replace(node.loc.assignment, "; ")
@@ -33,14 +32,12 @@ module RubyNext
           )
         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
+        def on_defs(node)
+          return process_defs(node) if endless?(node)
+          super(node)
         end
 
-        def on_defs_e(node)
+        def process_defs(node)
           context.track! self
 
           replace(node.loc.assignment, "; ")
@@ -57,6 +54,12 @@ module RubyNext
             )
           )
         end
+
+        private
+
+        def endless?(node)
+          node.loc.end.nil?
+        end
       end
     end
   end

data/lib/ruby-next/language/rewriters/{find_pattern.rb → 3.0/find_pattern.rb}

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "ruby-next/language/rewriters/pattern_matching"
-
 module RubyNext
   module Language
     module Rewriters
@@ -22,7 +20,7 @@ module RubyNext
           end
         end
 
-        def on_in_match(node)
+        def on_match_pattern(node)
           @has_find_pattern = false
           process_regular_node(node).then do |new_node|
             return new_node unless has_find_pattern

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      using RubyNext
+
+      # Separate pattern matching rewriter for Ruby 2.7 to
+      # transpile only `in` patterns
+      class InPattern < PatternMatching
+        NAME = "pattern-matching-in"
+        SYNTAX_PROBE = "1 in 2"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.0.0")
+
+        # Make case-match no-op
+        def on_case_match(node)
+          process_regular_node(node)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class AnonymousBlock < Base
+        NAME = "anonymous-block"
+        SYNTAX_PROBE = "obj = Object.new; def obj.foo(&) bar(&); end"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.1.0")
+
+        BLOCK = :__block__
+
+        def on_args(node)
+          block = node.children.last
+
+          return super unless block&.type == :blockarg
+          return super unless block.children.first.nil?
+
+          context.track! self
+
+          replace(block.loc.expression, "&#{BLOCK}")
+
+          node.updated(
+            :args,
+            [
+              *node.children.slice(0, node.children.index(block)),
+              s(:blockarg, BLOCK)
+            ]
+          )
+        end
+
+        def on_send(node)
+          block = extract_block_pass(node)
+          return super unless block&.children == [nil]
+
+          process_block(node, block)
+        end
+
+        def on_super(node)
+          block = extract_block_pass(node)
+          return super unless block&.children == [nil]
+
+          process_block(node, block)
+        end
+
+        private
+
+        def extract_block_pass(node)
+          node.children.find { |child| child.is_a?(::Parser::AST::Node) && child.type == :block_pass }
+        end
+
+        def process_block(node, block)
+          replace(block.loc.expression, "&#{BLOCK}")
+
+          process(
+            node.updated(
+              nil,
+              [
+                *node.children.take(node.children.index(block)),
+                s(:block_pass, s(:lvar, BLOCK))
+              ]
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class EndlessMethodCommand < EndlessMethod
+        NAME = "endless-method-command"
+        SYNTAX_PROBE = "obj = Object.new; def obj.foo = puts 'Hello'"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.1.0")
+
+        def process_def(node)
+          return node unless command?(node)
+
+          super(node)
+        end
+
+        def process_defs(node)
+          return node unless command?(node)
+
+          super(node)
+        end
+
+        private
+
+        def command?(node)
+          buffer = ::Parser::Source::Buffer.new("(endless-method-rewriter)").tap do |buffer|
+            buffer.source = node.loc.expression.source
+          end
+
+          parser30.parse(buffer)
+          false
+        rescue ::Parser::SyntaxError
+          true
+        end
+
+        def parser30
+          require "parser/ruby30" unless defined?(::Parser::Ruby30)
+
+          ::Parser::Ruby30.new(Language::Builder.new).tap do |prs|
+            prs.diagnostics.all_errors_are_fatal = true
+          end
+        end
+      end
+    end
+  end
+end