ruby-next-core 0.15.2 → 1.0.0.rc.1

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

@@ -4,57 +4,65 @@
 # 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)
+  def import_methods(*others, bind)
     import = []
 
-    other.instance_methods(false).each do |mid|
-      # check for non-Ruby methods
-      meth = other.instance_method(mid)
-      location = meth.source_location
+    # First, validate passed modules
+    others.each do |other|
+      raise TypeError, "wrong argument type #{other.class} (expected Module)" unless other.is_a?(::Module)
+      raise TypeError, "wrong argument type Class (expected Module)" if other.is_a?(::Class)
+    end
 
-      if location.nil? || location.first.match?(/(<internal:|resource:\/truffleruby\/core)/)
-        raise ArgumentError, "Can't import method: #{other}##{mid} from #{location}"
-      end
+    others.each do |other|
+      (other.instance_methods(false) + other.private_instance_methods(false)).each do |mid|
+        # check for non-Ruby methods
+        meth = other.instance_method(mid)
+        location = meth.source_location
 
-      source_file, lineno = *location
+        if location.nil? || location.first.match?(/(<internal:|resource:\/truffleruby\/core|uri:classloader:\/jruby)/)
+          raise ArgumentError, "Can't import method which is not defined with Ruby code: #{other}##{mid} from #{location}"
+        end
 
-      raise ArgumentError, "Can't import dynamicly added methods: #{other}##{mid}" unless File.file?(source_file)
+        source_file, lineno = *location
 
-      lines = File.open(source_file).readlines
+        raise ArgumentError, "Can't import dynamicly added methods: #{other}##{mid}" unless File.file?(source_file)
 
-      buffer = []
+        lines = File.open(source_file).readlines
 
-      lines[(lineno - 1)..-1].each do |line|
-        buffer << line + "\n"
+        buffer = []
 
-        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
+        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
+            # 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
-          break
-        rescue SyntaxError
         end
-      end
 
-      import << [buffer.join, source_file, lineno] unless buffer.empty?
-    end
+        import << [buffer.join, source_file, lineno] unless buffer.empty?
+      end
 
-    import.each do |(definition, file, lino)|
-      Kernel.eval definition, bind, file, lino
-    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 # rubocop:disable Style/EvalWithLocation
+      # Copy constants (they could be accessed from methods)
+      other.constants.each do |name|
+        Kernel.eval "#{name} = #{other}::#{name}", bind # rubocop:disable Style/EvalWithLocation
+      end
     end
   end
 end

data/lib/ruby-next/core/time/deconstruct_keys.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+RubyNext::Core.patch Time, method: :deconstruct_keys, version: "3.2" do
+  <<-'RUBY'
+def deconstruct_keys(keys)
+  raise TypeError, "wrong argument type #{keys.class} (expected Array or nil)" if keys && !keys.is_a?(Array)
+
+  if !keys
+    return {
+      year: year,
+      month: month,
+      day: day,
+      yday: yday,
+      wday: wday,
+      hour: hour,
+      min: min,
+      sec: sec,
+      subsec: subsec,
+      dst: dst?,
+      zone: zone
+    }
+  end
+
+  keys.each_with_object({}) do |key, hash|
+    hash[key] = public_send(key) if key.is_a?(Symbol) && respond_to?(key)
+    hash
+  end
+end
+  RUBY
+end

data/lib/ruby-next/core.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "set"
+require "set" # rubocop:disable Lint/RedundantRequireStatement
 
 require "ruby-next/config"
 require "ruby-next/utils"
@@ -78,7 +78,7 @@ module RubyNext
       end
 
       def native_location?(location)
-        location.nil? || location.first.match?(/(<internal:|resource:\/truffleruby\/core)/)
+        location.nil? || location.first.match?(/(<internal:|resource:\/truffleruby\/core|uri:classloader:\/jruby)/)
       end
     end
 
@@ -197,6 +197,11 @@ require "ruby-next/core/matchdata/match"
 require "ruby-next/core/enumerable/compact"
 require "ruby-next/core/integer/try_convert"
 
+require "ruby-next/core/matchdata/deconstruct"
+require "ruby-next/core/matchdata/deconstruct_keys"
+require "ruby-next/core/matchdata/named_captures"
+require "ruby-next/core/time/deconstruct_keys"
+
 # Generate refinements
 RubyNext.module_eval do
   RubyNext::Core.patches.refined.each do |mod, patches|
@@ -210,3 +215,6 @@ RubyNext.module_eval do
     end
   end
 end
+
+# Load backports
+require "ruby-next/core/data" unless ENV["RUBY_NEXT_DISABLE_DATA"] == "true"

data/lib/ruby-next/irb.rb

@@ -9,14 +9,14 @@ require "ruby-next/language"
 # IRB extension to transpile code before evaluating
 module RubyNext
   module IRBExt
-    def evaluate(context, statements, *args)
+    def eval(statements, *args)
       new_statements = ::RubyNext::Language.transform(
         statements,
         rewriters: ::RubyNext::Language.current_rewriters,
         using: false
       )
 
-      super(context, new_statements, *args)
+      super(new_statements, *args)
     end
   end
 end

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

@@ -1,28 +1,5 @@
 # frozen_string_literal: true
 
-require "ruby-next"
-require "ruby-next/utils"
-require "ruby-next/language"
+warn "[DEPRECATED] Using ruby-next/language/bootsnap is deprecated. Please use ruby-next/language/runtime instead."
 
-RubyNext::Language.runtime!
-
-# Patch bootsnap to transform source code.
-# Based on https://github.com/kddeisz/preval/blob/master/lib/preval.rb
-load_iseq = RubyVM::InstructionSequence.method(:load_iseq)
-
-if load_iseq.source_location[0].include?("/bootsnap/")
-  Bootsnap::CompileCache::ISeq.singleton_class.prepend(
-    Module.new do
-      def input_to_storage(source, path, *)
-        return super unless RubyNext::Language.transformable?(path)
-        source = RubyNext::Language.transform(source, rewriters: RubyNext::Language.current_rewriters)
-
-        RubyNext.debug_source(source, path)
-
-        RubyVM::InstructionSequence.compile(source, path, path).to_binary
-      rescue SyntaxError
-        raise Bootsnap::CompileCache::Uncompilable, "syntax error"
-      end
-    end
-  )
-end
+require "ruby-next/language/runtime"

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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "paco"
+
+require "ruby-next/language/paco_parsers/base"
+require "ruby-next/language/paco_parsers/comments"
+require "ruby-next/language/paco_parsers/string_literals"

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module PacoParsers
+      class Base
+        include Paco
+
+        def parse(io)
+          default.parse(io)
+        end
+
+        private
+
+        def anything_between(left, right)
+          seq(
+            left,
+            many(not_followed_by(right).bind { any_char }).join,
+            right
+          ).join
+        end
+
+        def starting_string(str)
+          index.bind do |index|
+            (index.column > 1) ? failed("1 column") : string(str)
+          end
+        end
+
+        def balanced(l, r, inner)
+          left = string(l)
+          right = string(r)
+
+          many(
+            alt(
+              seq(
+                left,
+                lazy { balanced(l, r, inner) },
+                right
+              ),
+              not_followed_by(right).bind { inner }
+            )
+          )
+        end
+      end
+    end
+  end
+end

data/lib/ruby-next/language/paco_parsers/comments.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module PacoParsers
+      class Comments < Base
+        def default
+          alt(
+            line_comment,
+            block_comment
+          )
+        end
+
+        # Matches a Ruby line comment (from `#` till the end of the line)
+        def line_comment
+          anything_between(string("#"), end_of_line)
+        end
+
+        # Matches a Ruby block comment (from `=begin` till `=end`)
+        def block_comment
+          anything_between(starting_string("=begin"), starting_string("=end"))
+        end
+      end
+    end
+  end
+end

data/lib/ruby-next/language/paco_parsers/string_literals.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module PacoParsers
+      class StringLiterals < Base
+        PAIRS = {"[" => "]", "{" => "}", "<" => ">"}.freeze
+
+        def default
+          all_strings.fmap do |result|
+            reduce_tokens(result.flatten)
+          end
+        end
+
+        def all_strings
+          alt(
+            single_quoted,
+            double_quoted,
+            external_cmd_exec,
+            quoted,
+            quoted_expanded
+          )
+          # heredoc,
+          # heredoc_expanded
+        end
+
+        def quoted
+          seq(
+            string("%q"),
+            any_char.bind do |char|
+              end_symbol = string(PAIRS[char] || char)
+              escapable_string(succeed(char), end_symbol)
+            end
+          )
+        end
+
+        def single_quoted
+          escapable_string(string("'"))
+        end
+
+        def quoted_expanded
+          seq(
+            alt(string("%Q"), string("%")),
+            any_char.bind do |char|
+              end_symbol = string(PAIRS[char] || char)
+              escapable_string(succeed(char), end_symbol, interpolate: true)
+            end
+          )
+        end
+
+        def external_cmd_exec
+          escapable_string(string("`"), interpolate: true)
+        end
+
+        def double_quoted
+          escapable_string(string('"'), interpolate: true)
+        end
+
+        def escapable_string(left, right = nil, interpolate: false)
+          right ||= left
+          seq(
+            left,
+            many(
+              alt(
+                *[
+                  seq(string("\\"), right).fmap { [:literal, _1] },
+                  interpolate ? seq(
+                    string('#{'),
+                    lazy { alt(balanced("{", "}", alt(all_strings, any_char)), many(none_of("}"))) },
+                    string("}")
+                  ) : nil,
+                  not_followed_by(right).bind { any_char }.fmap { [:literal, _1] }
+                ].compact
+              )
+            ),
+            right
+          )
+        end
+
+        private
+
+        def reduce_tokens(tokens)
+          state = :literal
+
+          tokens.each_with_object([]) do |v, acc|
+            if v == :literal
+              acc << [:literal, +""] unless state == :literal
+              state = :next_literal
+              next acc
+            end
+
+            if state == :next_literal
+              state = :literal
+              acc.last[1] << v
+              next acc
+            end
+
+            if state == :literal
+              acc << [:code, +""]
+            end
+
+            state = :code
+            acc.last[1] << v
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
-require "parser/rubynext"
+begin
+  require "parser/prism"
+rescue LoadError
+  require "parser/ruby33"
+end
 
 module RubyNext
   module Language
@@ -22,11 +26,18 @@ module RubyNext
       unless method_defined?(:match_pattern_p)
         include BuilderExt
       end
+
+      def check_reserved_for_numparam(name, loc)
+        # We don't want to raise SyntaxError, 'cause we want to use _x vars for older Rubies.
+        # The exception should be raised by Ruby itself for versions supporting numbered parameters
+      end
     end
 
     class << self
+      attr_accessor :parser_class
+
       def parser
-        ::Parser::RubyNext.new(Builder.new).tap do |prs|
+        parser_class.new(Builder.new).tap do |prs|
           prs.diagnostics.tap do |diagnostics|
             diagnostics.all_errors_are_fatal = true
           end
@@ -53,5 +64,16 @@ module RubyNext
         raise ::SyntaxError, e.message
       end
     end
+
+    # Set up default parser
+    unless parser_class
+      self.parser_class = if defined?(::Parser::RubyNext)
+        ::Parser::RubyNext
+      elsif defined?(::Parser::Prism)
+        ::Parser::Prism
+      else
+        ::Parser::Ruby33
+      end
+    end
   end
 end

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

@@ -425,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))
@@ -663,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
@@ -671,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)
@@ -844,6 +860,15 @@ module RubyNext
           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?
@@ -884,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)

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)