ruby-next-core 0.15.1 → 0.15.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fc36fd395eedfde5c29e65f1f3a75c683630d5111349b3070d3b4e6d200477ad
-  data.tar.gz: e53e28aec62f7e425a98ba1eeb9591778ca1dbab13a0390113fc7440aab9663d
+  metadata.gz: 6020fe263af1a0313e82b5633c45ee76950e7d39bd1f4e70f9d2613eb6ba3fec
+  data.tar.gz: 3a1c6da894f68e5e703f0515239bf342852d45f4f5672f68f8fe4011a0e76c57
 SHA512:
-  metadata.gz: 50069c2ef6b59005d7efc640e1d84a74e17e4e385aaadce3ac54c2e3e061c7f71b727943140899210af997196f0bdf5a1157b86b97ce7af3de307e68a1cffe12
-  data.tar.gz: edf464100a254380bee320c586f48afc35782027303840fd319f32260ac5cf771c6f349d7447b9ed2f8a55bab424395664099dbd58600a05ffcd79e49080509f
+  metadata.gz: dffe0bf9d32e02cd71aee8f5818d4413a62d96c8d595706c476bee2990823cf960240162b79d51d62036d2bb4a0076b46cba5af93c58760064aae165a82cd6e4
+  data.tar.gz: 22879525ffbbbd38921b096ef909ad79d5a87d726dae39f6a108aea2dc82ae5605e6a8e1bd9a190689e0a5da66fc897c6d8d22590f9a237416cd9a79aca43a38

data/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 ## master
 
+## 0.15.3 (2022-10-16)
+
+- Fix handling nested const patterns. ([@palkan][])
+
+## 0.15.2 (2022-08-02)
+
+- Fix loading transpiled in TruffleRuby. ([@palkan][])
+
+TruffleRuby doesn't support all Ruby 3.0 features yet, so we should treat as an older Ruby.
+
+- Use `ruby2_keywords` when transpiling arguments forwarding. ([@palkan][])
+
+That makes transpiled code forward compatible with the modern Ruby versions.
+
 ## 0.15.1 (2022-04-05)
 
 - Fix transpiling `rescue` within nested blocks. ([@palkan][])

data/lib/.rbnext/2.1/ruby-next/core.rb

@@ -125,7 +125,7 @@ module RubyNext
 
       def patch(*__rest__, &__block__)
         patches << Patch.new(*__rest__, &__block__)
-      end
+      end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :patch)
 
       # Inject `using RubyNext` at the top of the source code
       def inject!(contents)

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

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class ArgsForward < Base
+        NAME = "args-forward"
+        SYNTAX_PROBE = "obj = Object.new; def obj.foo(...) super(...); end"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("2.7.0")
+
+        REST = :__rest__
+        BLOCK = :__block__
+
+        def on_args(node)
+          farg = node.children.find { |child| child.is_a?(::Parser::AST::Node) && child.type == :forward_arg }
+          return unless farg
+
+          context.track! self
+
+          node = super(node)
+
+          replace(farg.loc.expression, "*#{REST}, &#{BLOCK}")
+
+          node.updated(
+            :args,
+            [
+              *node.children.slice(0, node.children.index(farg)),
+              s(:restarg, REST),
+              s(:blockarg, BLOCK)
+            ]
+          )
+        end
+
+        def on_send(node)
+          fargs = extract_fargs(node)
+          return super(node) unless fargs
+
+          process_fargs(node, fargs)
+        end
+
+        def on_super(node)
+          fargs = extract_fargs(node)
+          return super(node) unless fargs
+
+          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 ((((__safe_lvar__ = args) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.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
+
+        def process_fargs(node, fargs)
+          replace(fargs.loc.expression, "*#{REST}, &#{BLOCK}")
+
+          process(
+            node.updated(
+              nil,
+              [
+                *node.children.take(node.children.index(fargs)),
+                *forwarded_args
+              ]
+            )
+          )
+        end
+
+        def forwarded_args
+          [
+            s(:splat, s(:lvar, REST)),
+            s(:block_pass, s(:lvar, BLOCK))
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/.rbnext/2.3/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/.rbnext/2.7/ruby-next/core.rb

@@ -125,7 +125,7 @@ module RubyNext
 
       def patch(*__rest__, &__block__)
         patches << Patch.new(*__rest__, &__block__)
-      end
+      end; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :patch)
 
       # Inject `using RubyNext` at the top of the source code
       def inject!(contents)

data/lib/.rbnext/2.7/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/cli.rb

@@ -24,9 +24,6 @@ module RubyNext
       "core_ext" => Commands::CoreExt
     }.freeze
 
-    def initialize
-    end
-
     def run(args = ARGV)
       maybe_print_version(args)
 

data/lib/ruby-next/config.rb

@@ -19,8 +19,8 @@ module RubyNext
   NEXT_VERSION = "1995.next.0"
 
   class << self
-    # TruffleRuby claims it's 2.7.2 compatible but...
-    if defined?(TruffleRuby) && ::RUBY_VERSION =~ /^2\.7/
+    # TruffleRuby claims its RUBY_VERSION to be X.Y while not supporting all the features
+    if defined?(TruffleRuby)
       def current_ruby_version
         "2.6.5"
       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

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/setup.rb

@@ -12,7 +12,7 @@ module RubyNext
         return if File.directory?(target_dir)
 
         Dir.chdir(root_dir) do
-          unless system("bundle exec ruby-next nextify ./#{lib_dir} -o #{target_dir} --min-version=#{RUBY_VERSION} > /dev/null 2>&1")
+          unless system("bundle exec ruby-next nextify ./#{lib_dir} -o #{target_dir} --min-version=#{RubyNext.current_ruby_version} > /dev/null 2>&1")
             RubyNext.warn "Traspiled files are missing in: #{target_dir}. \n" \
               "Make sure you have gem 'ruby-next' in your Gemfile to auto-transpile the required files from source on load. " \
               "Otherwise the code from #{root_dir} may not work correctly."

data/lib/ruby-next/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyNext
-  VERSION = "0.15.1"
+  VERSION = "0.15.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-next-core
 version: !ruby/object:Gem::Version
-  version: 0.15.1
+  version: 0.15.3
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-04-05 00:00:00.000000000 Z
+date: 2022-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-next-parser
@@ -62,6 +62,7 @@ files:
 - lib/.rbnext/2.3/ruby-next/commands/nextify.rb
 - lib/.rbnext/2.3/ruby-next/language/eval.rb
 - lib/.rbnext/2.3/ruby-next/language/rewriters/2.6/endless_range.rb
+- lib/.rbnext/2.3/ruby-next/language/rewriters/2.7/args_forward.rb
 - lib/.rbnext/2.3/ruby-next/language/rewriters/2.7/pattern_matching.rb
 - lib/.rbnext/2.3/ruby-next/language/rewriters/3.1/anonymous_block.rb
 - lib/.rbnext/2.3/ruby-next/language/rewriters/base.rb
@@ -170,7 +171,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.7
+rubygems_version: 3.3.11
 signing_key:
 specification_version: 4
 summary: Ruby Next core functionality