ruby-next-core 0.13.0 → 0.14.0

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}

@@ -306,6 +306,38 @@ module RubyNext
 
         alias on_in_match on_match_pattern
 
+        def on_match_pattern_p(node)
+          context.track! self
+
+          @deconstructed_keys = {}
+          @predicates = Predicates::Noop.new
+
+          matchee =
+            s(:begin, s(:lvasgn, MATCHEE, node.children[0]))
+
+          pattern =
+            locals.with(
+              matchee: MATCHEE,
+              arr: MATCHEE_ARR,
+              hash: MATCHEE_HASH
+            ) do
+              send(
+                :"#{node.children[1].type}_clause",
+                node.children[1]
+              )
+            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)
@@ -407,13 +439,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) unless var.is_a?(::Parser::AST::Node)
 
           s(:begin,
             s(:or,
-              s(:begin, s(:lvasgn, node.children[0], left)),
+              s(:begin, build_var_assignment(var, left)),
               s(:true)))
         end
 
@@ -512,7 +545,7 @@ module RubyNext
 
           head_match =
             unless head.children.empty?
-              match_vars << s(:lvasgn, head.children[0].children[0])
+              match_vars << build_var_assignment(head.children[0].children[0])
 
               arr_take = s(:send,
                 s(:lvar, locals[:arr]),
@@ -524,16 +557,16 @@ module RubyNext
 
           tail_match =
             unless tail.children.empty?
-              match_vars << s(:lvasgn, tail.children[0].children[0])
+              match_vars << 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])
+              match_vars << build_var_assignment(node.children[0])
             elsif node.type == :match_as
-              match_vars << s(:lvasgn, node.children[1].children[0])
+              match_vars << build_var_assignment(node.children[1].children[0])
             end
           end
 
@@ -861,6 +894,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
@@ -968,6 +1005,15 @@ 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)
+          return s(:lvasgn, *[var, value].compact) unless var.is_a?(::Parser::AST::Node)
+
+          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

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      using RubyNext
+
+      # Allow omitting parentheses around patterns in `=>` and `in`
+      class OnelinePatternParensless < Base
+        NAME = "pattern-matching-oneline-parensless"
+        SYNTAX_PROBE = "[1, 2] => a, b"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.1.0")
+
+        def on_match_pattern(node)
+          _, pattern = *node.children
+
+          # When no parens, children boundaries are the same as the whole pattern
+          if (
+            pattern.type == :array_pattern ||
+            pattern.type == :hash_pattern
+          ) &&
+              pattern.children.any? &&
+              pattern.loc.column == pattern.children.first.loc.column &&
+              pattern.loc.last_column == pattern.children.last.loc.last_column
+
+            context.track! self
+
+            left_p, right_p = pattern.type == :array_pattern ? %w([ ]) : %w[{ }]
+
+            insert_before(pattern.loc.expression, left_p)
+            insert_after(pattern.loc.expression, right_p)
+          else
+            super(node)
+          end
+        end
+
+        alias on_match_pattern_p on_match_pattern
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      using RubyNext
+
+      # Separate pattern matching rewriter for Ruby 2.7 and 3.0 to
+      # transpile only ^(ivar|cvar|gvar)
+      class PinVarsPattern < PatternMatching
+        NAME = "pattern-matching-pin-vars"
+        SYNTAX_PROBE = "@a = 0; case 0; in ^@a; true; end"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.1.0")
+
+        def on_case_match(node)
+          @has_pin_vars = false
+          process_regular_node(node).then do |new_node|
+            return new_node unless has_pin_vars
+            super(node)
+          end
+        end
+
+        def on_match_pattern(node)
+          @has_pin_vars = false
+          process_regular_node(node).then do |new_node|
+            return new_node unless has_pin_vars
+            super(node)
+          end
+        end
+
+        def on_match_pattern_p(node)
+          @has_pin_vars = false
+          process_regular_node(node).then do |new_node|
+            return new_node unless has_pin_vars
+            super(node)
+          end
+        end
+
+        def on_pin(node)
+          @has_pin_vars = node.children.first.type != :lvar
+          super(node)
+        end
+
+        private
+
+        attr_reader :has_pin_vars
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# Add binding argument to all self-less eval's
+module RubyNext
+  module Language
+    module Rewriters
+      class RefinementImportMethods < Language::Rewriters::Base
+        NAME = "refinement-import-methods"
+        SYNTAX_PROBE = "a = Module.new{}; Module.new do; refine String do; import_methods a end; end"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.1.0")
+
+        def on_block(node)
+          sender, args, body = *node
+          receiver, mid, * = *sender
+
+          return super unless mid == :refine && receiver.nil?
+
+          return super unless body
+
+          @within_refinement = true
+
+          node.updated(
+            nil,
+            [
+              sender,
+              args,
+              process(body)
+            ]
+          ).tap do
+            @within_refinement = false
+          end
+        end
+
+        def on_send(node)
+          return super unless @within_refinement
+
+          _receiver, mid, *children = *node
+
+          return super unless mid == :import_methods
+
+          context.track! self
+
+          updated = node.updated(
+            nil,
+            [
+              s(:const, s(:const, s(:cbase), :RubyNext), :Core),
+              mid,
+              *children,
+              s(:send, nil, :binding)
+            ]
+          )
+
+          replace(node.loc.expression, updated)
+
+          updated
+        end
+      end
+    end
+  end
+end

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

@@ -5,13 +5,15 @@ module RubyNext
     module Rewriters
       class ShorthandHash < Base
         NAME = "shorthand-hash"
-        SYNTAX_PROBE = "data = {x}"
-        MIN_SUPPORTED_VERSION = Gem::Version.new(RubyNext::NEXT_VERSION)
+        SYNTAX_PROBE = "data = {x:}"
+        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
 
-        def on_ipair(node)
           context.track! self
 
-          ident, = *node.children
+          _, ident, = *node.children
 
           key = key_from_ident(ident)
 

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

@@ -15,6 +15,18 @@ module RubyNext
 
       class Base < ::Parser::TreeRewriter
         class LocalsTracker
+          using(Module.new do
+            refine ::Parser::AST::Node do
+              def to_index
+                children&.first || type
+              end
+            end
+
+            refine ::Object do
+              alias to_index itself
+            end
+          end)
+
           attr_reader :stacks
 
           def initialize
@@ -29,7 +41,7 @@ module RubyNext
           def [](name, suffix = nil)
             fetch(name).then do |name|
               next name unless suffix
-              :"#{name}#{suffix}__"
+              :"#{name}#{suffix.to_index}__"
             end
           end