ruby-next-core 0.14.0 → 1.0.1

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+RubyNext::Core.patch MatchData, method: :named_captures, version: "3.3", supported: "a".match(/a/).method(:named_captures).arity != 0, core_ext: :prepend do
+  <<-'RUBY'
+def named_captures(symbolize_names: false)
+  return super() unless symbolize_names
+
+  super().transform_keys!(&:to_sym)
+end
+  RUBY
+end

data/lib/ruby-next/core/proc/compose.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-# rubocop:disable Style/LambdaCall
 RubyNext::Core.patch Proc, name: "ProcCompose", method: :<<, version: "2.6" do
   <<-RUBY
 def <<(other)

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
+      # 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"
@@ -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/, "") # rubocop:disable Performance/StringReplacement
+        "#{mod_name}#{camelized_method_name}".gsub(/\W/, "")
       end
 
       def build_location(trace_locations)
@@ -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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "ruby-next"
+# Include RubyNext into TOPLEVEL_BINDING for polyfills to work
+eval("using RubyNext", TOPLEVEL_BINDING, __FILE__, __LINE__)
+
+require "ruby-next/language"
+
+# IRB extension to transpile code before evaluating
+module RubyNext
+  module IRBExt
+    def eval(statements, *args)
+      new_statements = ::RubyNext::Language.transform(
+        statements,
+        rewriters: ::RubyNext::Language.current_rewriters,
+        using: false
+      )
+
+      super(new_statements, *args)
+    end
+  end
+end
+
+IRB::WorkSpace.prepend(RubyNext::IRBExt)

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/2.5/rescue_within_block.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class RescueWithinBlock < Base
+        NAME = "rescue-within-block"
+        SYNTAX_PROBE = "lambda do
+          raise 'err'
+        rescue
+          $! # => #<RuntimeError: err>
+        end.call"
+
+        MIN_SUPPORTED_VERSION = Gem::Version.new("2.5.0")
+
+        def on_block(block_node)
+          exception_node = block_node.children.find do |node|
+            node && (node.type == :rescue || node.type == :ensure)
+          end
+
+          return super(block_node) unless exception_node
+
+          context.track! self
+
+          insert_before(exception_node.loc.expression, "begin;")
+          insert_after(exception_node.loc.expression, ";end")
+
+          new_children = block_node.children.map do |child|
+            next s(:kwbegin, exception_node) if child == exception_node
+
+            child
+          end
+
+          process(
+            block_node.updated(:block, new_children)
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -45,8 +45,65 @@ module RubyNext
           process_fargs(node, fargs)
         end
 
+        def on_def(node)
+          return super unless forward_arg?(node.children[1])
+
+          new_node = super
+
+          name = node.children[0]
+
+          insert_after(node.loc.expression, "; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :#{name})")
+
+          s(:begin,
+            new_node,
+            ruby2_keywords_node(nil, name))
+        end
+
+        def on_defs(node)
+          return super unless forward_arg?(node.children[2])
+
+          new_node = super
+
+          receiver = node.children[0]
+          name = node.children[1]
+
+          # Using self.ruby2_keywords :name results in undefined method error,
+          # singleton_class works as expected
+          receiver = s(:send, nil, :singleton_class) if receiver.type == :self
+
+          receiver_name =
+            case receiver.type
+            when :send
+              receiver.children[1]
+            when :const
+              receiver.children[1]
+            end
+
+          insert_after(node.loc.expression, "; #{receiver_name}.respond_to?(:ruby2_keywords, true) && (#{receiver_name}.send(:ruby2_keywords, :#{name}))")
+
+          s(:begin,
+            new_node,
+            ruby2_keywords_node(receiver, name))
+        end
+
         private
 
+        def ruby2_keywords_node(receiver, name)
+          s(:and,
+            s(:send, receiver, :respond_to?,
+              s(:sym, :ruby2_keywords), s(:true)),
+            s(:begin,
+              s(:send, receiver, :send,
+                s(:sym, :ruby2_keywords),
+                s(:sym, name))))
+        end
+
+        def forward_arg?(args)
+          return false unless args&.children
+
+          args.children.any? { |arg| arg.type == :forward_arg }
+        end
+
         def extract_fargs(node)
           node.children.find { |child| child.is_a?(::Parser::AST::Node) && child.type == :forwarded_args }
         end