ruby-next-core 0.10.5 → 0.11.0

data/lib/ruby-next/commands/nextify.rb

@@ -57,7 +57,7 @@ module RubyNext
 
           opts.on(
             "--transpile-mode=MODE",
-            "Transpiler mode (ast or rewrite). Default: ast"
+            "Transpiler mode (ast or rewrite). Default: rewrite"
           ) do |val|
             Language.mode = val.to_sym
           end

data/lib/ruby-next/config.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RubyNext
+  # Mininum Ruby version supported by RubyNext
+  MIN_SUPPORTED_VERSION = Gem::Version.new("2.2.0")
+
+  # Where to store transpiled files (relative from the project LOAD_PATH, usually `lib/`)
+  RUBY_NEXT_DIR = ".rbnext"
+
+  # Defines last minor version for every major version
+  LAST_MINOR_VERSIONS = {
+    2 => 8, # 2.8 is required for backward compatibility: some gems already uses it
+    3 => 0
+  }.freeze
+
+  LATEST_VERSION = [3, 0].freeze
+
+  class << self
+    # TruffleRuby claims it's 2.7.2 compatible but...
+    if defined?(TruffleRuby) && ::RUBY_VERSION =~ /^2\.7/
+      def current_ruby_version
+        "2.6.5"
+      end
+    else
+      def current_ruby_version
+        ::RUBY_VERSION
+      end
+    end
+
+    def next_ruby_version(version = current_ruby_version)
+      major, minor = Gem::Version.new(version).segments.map(&:to_i)
+
+      return if major >= LATEST_VERSION.first && minor >= LATEST_VERSION.last
+
+      nxt =
+        if LAST_MINOR_VERSIONS[major] == minor
+          "#{major + 1}.0.0"
+        else
+          "#{major}.#{minor + 1}.0"
+        end
+
+      Gem::Version.new(nxt)
+    end
+  end
+end

data/lib/ruby-next/core.rb

@@ -2,6 +2,7 @@
 
 require "set"
 
+require "ruby-next/config"
 require "ruby-next/utils"
 
 module RubyNext
@@ -17,7 +18,7 @@ module RubyNext
       # `core_ext` defines the strategy for core extensions:
       #    - :patch — extend class directly
       #    - :prepend — extend class by prepending a module (e.g., when needs `super`)
-      def initialize(mod = nil, method:, name: nil, version:, supported: nil, native: nil, location: nil, refineable: mod, core_ext: :patch, singleton: nil)
+      def initialize(mod = nil, method:, version:, name: nil, supported: nil, native: nil, location: nil, refineable: mod, core_ext: :patch, singleton: nil)
         @mod = mod
         @method_name = method
         @version = version
@@ -122,8 +123,8 @@ module RubyNext
         strategy == :backports
       end
 
-      def patch(*args, **kwargs, &block)
-        patches << Patch.new(*args, **kwargs, &block)
+      def patch(...)
+        patches << Patch.new(...)
       end
 
       # Inject `using RubyNext` at the top of the source code
@@ -175,7 +176,7 @@ require "ruby-next/core/time/ceil"
 # Core extensions required for pattern matching
 # Required for pattern matching with refinements
 unless defined?(NoMatchingPatternError)
-  class NoMatchingPatternError < RuntimeError
+  class NoMatchingPatternError < StandardError
   end
 end
 

data/lib/ruby-next/core/array/deconstruct.rb

@@ -9,7 +9,7 @@ end
 end
 
 # We need to hack `respond_to?` in Ruby 2.5, since it's not working with refinements
-if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.6")
+if Gem::Version.new(::RubyNext.current_ruby_version) < Gem::Version.new("2.6")
   RubyNext::Core.patch refineable: Array, name: "ArrayRespondToDeconstruct", method: :deconstruct, version: "2.7" do
     <<-RUBY
 def respond_to?(mid, *)

data/lib/ruby-next/core/constants/no_matching_pattern_error.rb

@@ -11,7 +11,7 @@ RubyNext::Core.patch Object,
   supported: true,
   location: [__FILE__, __LINE__ + 2] do
   <<-RUBY
-class NoMatchingPatternError < RuntimeError
+class NoMatchingPatternError < StandardError
 end
   RUBY
 end

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

@@ -9,7 +9,7 @@ end
 end
 
 # We need to hack `respond_to?` in Ruby 2.5, since it's not working with refinements
-if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.6")
+if Gem::Version.new(::RubyNext.current_ruby_version) < Gem::Version.new("2.6")
   RubyNext::Core.patch refineable: Hash, name: "HashRespondToDeconstructKeys", method: :deconstruct_keys, version: "2.7" do
     <<-RUBY
 def respond_to?(mid, *)

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

@@ -10,9 +10,9 @@ def deconstruct_keys(keys)
 
   keys.each_with_object({}) do |k, acc|
     # if k is Symbol and not a member of a Struct return {}
-    next if (Symbol === k || String === k) && !members.include?(k.to_sym)
+    return {} if (Symbol === k || String === k) && !members.include?(k.to_sym)
     # if k is Integer check that index is not ouf of bounds
-    next if Integer === k && k > size - 1
+    return {} if Integer === k && k > size - 1
     acc[k] = self[k]
   end
 end
@@ -20,7 +20,7 @@ end
 end
 
 # We need to hack `respond_to?` in Ruby 2.5, since it's not working with refinements
-if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.6")
+if Gem::Version.new(::RubyNext.current_ruby_version) < Gem::Version.new("2.6")
   RubyNext::Core.patch refineable: Struct, name: "StructRespondToDeconstruct", method: :deconstruct_keys, version: "2.7" do
     <<-RUBY
 def respond_to?(mid, *)

data/lib/ruby-next/core_ext.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "ruby-next/config"
+require "ruby-next/setup_self"
 require "ruby-next/core"
 
 # Monkey-patch core classes using the same patches as for refinements

data/lib/ruby-next/language.rb

@@ -101,9 +101,9 @@ module RubyNext
           regenerate(*args, **kwargs)
         end
       rescue Unparser::UnknownNodeError
-        if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.7.0")
-          RubyNext.warn "Ruby Next fallbacks to \"rewrite\" transpiling mode since Unparser doesn't support 2.7+ AST yet.\n" \
-            "See https://github.com/mbj/unparser/pull/142"
+        if Gem::Version.new(::RubyNext.current_ruby_version) >= Gem::Version.new("3.0.0")
+          RubyNext.warn "Ruby Next fallbacks to \"rewrite\" transpiling mode since Unparser doesn't support 3.0+ AST yet.\n" \
+            "See https://github.com/mbj/unparser/issues/168"
           self.mode = :rewrite
         end
         rewrite(*args, **kwargs)
@@ -169,7 +169,7 @@ module RubyNext
 
     self.rewriters = []
     self.watch_dirs = %w[app lib spec test].map { |path| File.join(Dir.pwd, path) }
-    self.mode = ENV.fetch("RUBY_NEXT_TRANSPILE_MODE", "ast").to_sym
+    self.mode = ENV.fetch("RUBY_NEXT_TRANSPILE_MODE", "rewrite").to_sym
 
     require "ruby-next/language/rewriters/base"
 
@@ -182,6 +182,11 @@ module RubyNext
     require "ruby-next/language/rewriters/args_forward"
     rewriters << Rewriters::ArgsForward
 
+    # Must be added after general args forward rewriter to become
+    # no-op in Ruby <2.7
+    require "ruby-next/language/rewriters/args_forward_leading"
+    rewriters << Rewriters::ArgsForwardLeading
+
     require "ruby-next/language/rewriters/numbered_params"
     rewriters << Rewriters::NumberedParams
 
@@ -193,11 +198,17 @@ module RubyNext
     require "ruby-next/language/rewriters/find_pattern"
     rewriters << Rewriters::FindPattern
 
+    require "ruby-next/language/rewriters/in_pattern"
+    rewriters << Rewriters::InPattern
+
     # Put endless range in the end, 'cause Parser fails to parse it in
     # pattern matching
     require "ruby-next/language/rewriters/endless_range"
     rewriters << Rewriters::EndlessRange
 
+    require "ruby-next/language/rewriters/endless_method"
+    RubyNext::Language.rewriters << RubyNext::Language::Rewriters::EndlessMethod
+
     if ENV["RUBY_NEXT_EDGE"] == "1"
       require "ruby-next/language/edge"
     end

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

@@ -13,7 +13,7 @@ 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)
+      def input_to_storage(source, path, *)
         return super unless RubyNext::Language.transformable?(path)
         source = RubyNext::Language.transform(source, rewriters: RubyNext::Language.current_rewriters)
 

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

@@ -1,9 +1,3 @@
 # frozen_string_literal: true
 
 # Load edge Ruby features
-
-require "ruby-next/language/rewriters/endless_method"
-RubyNext::Language.rewriters << RubyNext::Language::Rewriters::EndlessMethod
-
-require "ruby-next/language/rewriters/right_hand_assignment"
-RubyNext::Language.rewriters << RubyNext::Language::Rewriters::RightHandAssignment

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

@@ -20,7 +20,7 @@ module RubyNext
     module InstanceEval # :nodoc:
       refine Object do
         def instance_eval(*args, &block)
-          return super(*args, &block) if block_given?
+          return super(*args, &block) if block
 
           source = args.shift
           new_source = ::RubyNext::Language::Runtime.transform(source, using: false)
@@ -33,7 +33,7 @@ module RubyNext
     module ClassEval
       refine Module do
         def module_eval(*args, &block)
-          return super(*args, &block) if block_given?
+          return super(*args, &block) if block
 
           source = args.shift
           new_source = ::RubyNext::Language::Runtime.transform(source, using: false)
@@ -42,7 +42,7 @@ module RubyNext
         end
 
         def class_eval(*args, &block)
-          return super(*args, &block) if block_given?
+          return super(*args, &block) if block
 
           source = args.shift
           new_source = ::RubyNext::Language::Runtime.transform(source, using: false)

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

@@ -4,8 +4,27 @@ require "parser/rubynext"
 
 module RubyNext
   module Language
+    module BuilderExt
+      def match_pattern(lhs, match_t, rhs)
+        n(:match_pattern, [lhs, rhs],
+          binary_op_map(lhs, match_t, rhs))
+      end
+
+      def match_pattern_p(lhs, match_t, rhs)
+        n(:match_pattern_p, [lhs, rhs],
+          binary_op_map(lhs, match_t, rhs))
+      end
+    end
+
     class Builder < ::Parser::Builders::Default
       modernize
+
+      # Unparser doesn't support kwargs node yet
+      self.emit_kwargs = false if respond_to?(:emit_kwargs=)
+
+      unless method_defined?(:match_pattern_p)
+        include BuilderExt
+      end
     end
 
     class << self

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

@@ -5,8 +5,8 @@ module RubyNext
     module Rewriters
       class ArgsForward < Base
         NAME = "args-forward"
-        SYNTAX_PROBE = "obj = Object.new; def obj.foo(...) super(1, ...); end"
-        MIN_SUPPORTED_VERSION = Gem::Version.new("3.0.0")
+        SYNTAX_PROBE = "obj = Object.new; def obj.foo(...) super(...); end"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("2.7.0")
 
         REST = :__rest__
         BLOCK = :__block__
@@ -28,14 +28,14 @@ module RubyNext
         end
 
         def on_send(node)
-          fargs = node.children.find { |child| child.is_a?(::Parser::AST::Node) && child.type == :forwarded_args }
+          fargs = extract_fargs(node)
           return super(node) unless fargs
 
           process_fargs(node, fargs)
         end
 
         def on_super(node)
-          fargs = node.children.find { |child| child.is_a?(::Parser::AST::Node) && child.type == :forwarded_args }
+          fargs = extract_fargs(node)
           return super(node) unless fargs
 
           process_fargs(node, fargs)
@@ -43,6 +43,10 @@ module RubyNext
 
         private
 
+        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}")
 

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class ArgsForwardLeading < ArgsForward
+        NAME = "args-forward-leading"
+        SYNTAX_PROBE = "obj = Object.new; def obj.foo(...) super(1, ...); end"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.0.0")
+
+        attr_reader :leading_farg
+        alias leading_farg? leading_farg
+
+        def on_def(node)
+          @leading_farg = method_with_leading_arg(node)
+
+          super
+        end
+
+        def on_defs(node)
+          @leading_farg = method_with_leading_arg(node)
+
+          super
+        end
+
+        def on_forward_arg(node)
+          return super if leading_farg?
+
+          node
+        end
+
+        def on_send(node)
+          return super if leading_farg?
+
+          node
+        end
+
+        def on_super(node)
+          return super if leading_farg?
+
+          node
+        end
+
+        private
+
+        def send_with_leading_farg(node)
+          return false unless node.type == :send || node.type == :super
+
+          fargs = extract_fargs(node)
+
+          return false unless fargs
+
+          node.children.index(fargs) > (node.type == :send ? 2 : 0)
+        end
+
+        def method_with_leading_arg(node)
+          find_child(node) { |child| child.type == :forward_arg } &&
+            (
+              def_with_leading_farg(node) ||
+              find_child(node) { |child| send_with_leading_farg(child) }
+            )
+        end
+
+        def def_with_leading_farg(node)
+          args = node.type == :defs ? node.children[2] : node.children[1]
+          args = args.children
+
+          farg = args.detect { |child| child.type == :forward_arg }
+
+          args.index(farg) > 0
+        end
+      end
+    end
+  end
+end

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

@@ -61,7 +61,7 @@ module RubyNext
             eval_mid = Kernel.respond_to?(:eval_without_ruby_next) ? :eval_without_ruby_next : :eval
             Kernel.send eval_mid, self::SYNTAX_PROBE, nil, __FILE__, __LINE__
             false
-          rescue SyntaxError, NameError
+          rescue SyntaxError, StandardError
             true
           ensure
             $VERBOSE = save_verbose
@@ -94,6 +94,24 @@ module RubyNext
 
         private
 
+        # BFS with predicate block
+        def find_child(node)
+          queue = [node]
+
+          loop do
+            break if queue.empty?
+
+            child = queue.shift
+            next unless child.is_a?(::Parser::AST::Node)
+
+            return child if yield child
+
+            queue.push(*child.children)
+          end
+
+          nil
+        end
+
         def replace(range, ast)
           @source_rewriter&.replace(range, unparse(ast))
         end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "ruby-next/language/rewriters/pattern_matching"
+
+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)
+          node
+        end
+
+        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
+      end
+    end
+  end
+end