ruby-next-core 0.15.3 → 1.0.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/eval.rb

@@ -11,7 +11,7 @@ module RubyNext
               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
+            super(new_source, bind, *args)
           end
         end
       end
@@ -25,7 +25,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
+          super(new_source, *args)
         end
       end
     end
@@ -39,7 +39,7 @@ module RubyNext
           new_source = ::RubyNext::Language::Runtime.transform(source, using: false)
 
           RubyNext.debug_source(new_source, "(#{caller_locations(1, 1).first})")
-          super new_source, *args
+          super(new_source, *args)
         end
 
         def class_eval(*args, &block)
@@ -48,7 +48,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
+          super(new_source, *args)
         end
       end
     end

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, :parser_syntax_errors
+
       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
@@ -39,8 +50,8 @@ module RubyNext
         end
 
         parser.parse(buffer)
-      rescue ::Parser::SyntaxError => e
-        raise ::SyntaxError, e.message
+      rescue *parser_syntax_errors => e
+        raise ::SyntaxError, e.message, e.backtrace
       end
 
       def parse_with_comments(source, file = "(string)")
@@ -49,8 +60,22 @@ module RubyNext
         end
 
         parser.parse_with_comments(buffer)
-      rescue ::Parser::SyntaxError => e
-        raise ::SyntaxError, e.message
+      rescue *parser_syntax_errors => e
+        raise ::SyntaxError, e.message, e.backtrace
+      end
+    end
+
+    self.parser_syntax_errors = [::Parser::SyntaxError]
+
+    # Set up default parser
+    unless parser_class
+      self.parser_class = if defined?(::Parser::RubyNext)
+        ::Parser::RubyNext
+      elsif defined?(::Parser::Prism)
+        parser_syntax_errors << ::Prism::ParserCompiler::CompilationError
+        ::Parser::Prism
+      else
+        ::Parser::Ruby33
       end
     end
   end

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