ruby-next-core 0.10.5 → 0.13.0

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,24 @@ 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
+
+      unless method_defined?(:match_pattern_p)
+        include BuilderExt
+      end
     end
 
     class << self

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

@@ -5,22 +5,26 @@ 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__
 
-        def on_forward_arg(node)
+        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(node.loc.expression, "*#{REST}, &#{BLOCK}")
+          replace(farg.loc.expression, "*#{REST}, &#{BLOCK}")
 
           node.updated(
             :args,
             [
+              *node.children.slice(0, node.children.index(farg)),
               s(:restarg, REST),
               s(:blockarg, BLOCK)
             ]
@@ -28,14 +32,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 +47,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_args(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

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

@@ -6,7 +6,7 @@ module RubyNext
       class MethodReference < Base
         NAME = "method-reference"
         SYNTAX_PROBE = "Language.:transform"
-        MIN_SUPPORTED_VERSION = Gem::Version.new("3.0.0")
+        MIN_SUPPORTED_VERSION = Gem::Version.new(RubyNext::NEXT_VERSION)
 
         def on_meth_ref(node)
           context.track! self

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

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class NumericLiterals < Base
+        using RubyNext
+
+        NAME = "numeric-literals"
+        SYNTAX_PROBE = "2i + 1/2r"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("2.1.0")
+
+        def on_rational(node)
+          context.track! self
+
+          val = node.children.first
+
+          parts = [s(:int, val.numerator)]
+
+          parts << s(:int, val.denominator) unless val.denominator == 1
+
+          s(:send, nil, :Rational, *parts).tap do |new_node|
+            replace(node.loc.expression, new_node)
+          end
+        end
+
+        def on_complex(node)
+          context.track! self
+
+          val = node.children.first
+
+          s(:send, nil, :Complex,
+            s(:int, val.real),
+            s(:int, val.imaginary)).tap do |new_node|
+            replace(node.loc.expression, new_node)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -13,12 +13,12 @@ module RubyNext
 
           # Useful to generate simple operation nodes
           # (e.g., 'a + b')
-          def -(val)
-            ::Parser::AST::Node.new(:send, [self, :-, val.to_ast_node])
+          def -(other)
+            ::Parser::AST::Node.new(:send, [self, :-, other.to_ast_node])
           end
 
-          def +(val)
-            ::Parser::AST::Node.new(:send, [self, :+, val.to_ast_node])
+          def +(other)
+            ::Parser::AST::Node.new(:send, [self, :+, other.to_ast_node])
           end
         end
 
@@ -218,9 +218,10 @@ module RubyNext
             predicate_clause(:respond_to_deconstruct_keys, node)
           end
 
-          def hash_key(node, key)
-            key = key.children.first if key.is_a?(::Parser::AST::Node)
-            predicate_clause(:"hash_key_#{key}", node)
+          def hash_keys(node, keys)
+            keys = keys.map { |key| key.is_a?(::Parser::AST::Node) ? key.children.first : key }
+
+            predicate_clause(:"hash_keys_#{keys.join("_p_")}", node)
           end
         end
       end
@@ -266,7 +267,7 @@ module RubyNext
           )
         end
 
-        def on_in_match(node)
+        def on_match_pattern(node)
           context.track! self
 
           @deconstructed_keys = {}
@@ -303,6 +304,8 @@ module RubyNext
           end
         end
 
+        alias on_in_match on_match_pattern
+
         private
 
         def rewrite_case_in!(node, matchee, new_node)
@@ -350,7 +353,7 @@ module RubyNext
 
           else_clause = (else_clause || no_matching_pattern).then do |node|
             next node unless node.type == :empty_else
-            s(:empty)
+            nil
           end
 
           clauses << else_clause
@@ -883,14 +886,14 @@ module RubyNext
         end
 
         def having_hash_keys(keys, hash = s(:lvar, locals[:hash]))
-          key = keys.shift
-          node = predicates.hash_key(hash_has_key(key, hash), key)
+          keys.reduce(nil) do |acc, key|
+            pnode = hash_has_key(key, hash)
+            next pnode unless acc
 
-          keys.reduce(node) do |res, key|
             s(:begin,
-              s(:and,
-                res,
-                predicates.hash_key(hash_has_key(key, hash), key)))
+              s(:and, acc, pnode))
+          end.then do |node|
+            predicates.hash_keys(node, keys)
           end
         end
 

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class RequiredKwargs < Base
+        using RubyNext
+
+        NAME = "required-kwargs"
+        SYNTAX_PROBE = "obj = Object.new; def obj.foo(x:, y: 1); end"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("2.1.0")
+
+        def on_kwarg(node)
+          context.track! self
+
+          name = node.children[0]
+
+          new_node = node.updated(
+            :kwoptarg,
+            [name, raise_missing_keyword(name)]
+          )
+
+          replace(node.loc.expression, "#{name}: ::Kernel.raise(::ArgumentError, \"missing keyword: #{name}\")")
+
+          new_node
+        end
+
+        private
+
+        def raise_missing_keyword(name)
+          s(:send,
+            s(:const, s(:cbase), :Kernel), :raise,
+            s(:const, s(:cbase), :ArgumentError),
+            s(:str, "missing keyword: #{name}"))
+        end
+      end
+    end
+  end
+end

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

@@ -8,6 +8,8 @@ module RubyNext
         SYNTAX_PROBE = "nil&.x&.nil?"
         MIN_SUPPORTED_VERSION = Gem::Version.new("2.3.0")
 
+        SAFE_LVAR = :__safe_lvar__
+
         def on_csend(node)
           node = super(node)
 
@@ -20,7 +22,7 @@ module RubyNext
               :and,
               [
                 process(safe_navigation(receiver)),
-                s(:send, decsendize(receiver), *args)
+                s(:send, safe_lvar, *args)
               ]
             ))
 
@@ -34,18 +36,15 @@ module RubyNext
 
           context.track!(self)
 
-          new_node = s(:begin,
-            super(node.updated(
-              :and,
-              [
-                process(safe_navigation(node.children[0].children[0])),
-                process(node.updated(nil, node.children.map(&method(:decsendize))))
-              ]
-            )))
+          super(decsendize(node))
+        end
 
-          replace(node.loc.expression, new_node)
+        def on_numblock(node)
+          return super(node) unless node.children[0].type == :csend
 
-          new_node
+          context.track!(self)
+
+          super(decsendize(node))
         end
 
         def on_op_asgn(node)
@@ -53,37 +52,51 @@ module RubyNext
 
           context.track!(self)
 
+          super(decsendize(node))
+        end
+
+        private
+
+        def decsendize(node)
+          csend, *children = node.children
+
+          receiver, *other = csend.children
+
+          new_csend = csend.updated(:send, [safe_lvar, *other])
+
           new_node = s(:begin,
-            super(node.updated(
+            node.updated(
               :and,
               [
-                process(safe_navigation(node.children[0].children[0])),
-                process(node.updated(nil, node.children.map(&method(:decsendize))))
+                process(safe_navigation(receiver)),
+                process(node.updated(nil, [new_csend, *children]))
               ]
-            )))
+            ))
 
           replace(node.loc.expression, new_node)
 
           new_node
         end
 
-        private
-
-        def decsendize(node)
-          return node unless node.is_a?(::Parser::AST::Node) && node.type == :csend
-
-          node.updated(:send, node.children.map(&method(:decsendize)))
-        end
-
-        # Transform: x&.y -> (!x.nil? && x.y) || nil
+        # Transform: x&.y -> ((_tmp_ = x) || true) && (!_tmp_.nil? || nil) && _tmp_.y
         # This allows us to handle `false&.to_s == "false"`
         def safe_navigation(node)
           s(:begin,
-            s(:or,
-              s(:send,
-                s(:send, node, :nil?),
-                :!),
-              s(:nil)))
+            s(:and,
+              s(:begin,
+                s(:or,
+                  s(:begin, s(:lvasgn, SAFE_LVAR, node)),
+                  s(:true))),
+              s(:begin,
+                s(:or,
+                  s(:send,
+                    s(:send, safe_lvar, :nil?),
+                    :!),
+                  s(:nil)))))
+        end
+
+        def safe_lvar
+          s(:lvar, SAFE_LVAR)
         end
       end
     end

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

@@ -6,7 +6,7 @@ module RubyNext
       class ShorthandHash < Base
         NAME = "shorthand-hash"
         SYNTAX_PROBE = "data = {x}"
-        MIN_SUPPORTED_VERSION = Gem::Version.new("3.0.0")
+        MIN_SUPPORTED_VERSION = Gem::Version.new(RubyNext::NEXT_VERSION)
 
         def on_ipair(node)
           context.track! self

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

@@ -2,6 +2,7 @@
 
 # Make sure Core is loaded
 require "ruby-next"
+require "pathname"
 
 module RubyNext
   module Language
@@ -29,7 +30,7 @@ module RubyNext
 
       def setup_gem_load_path(lib_dir = "lib", rbnext_dir: RUBY_NEXT_DIR, transpile: false)
         called_from = caller_locations(1, 1).first.path
-        dirname = File.dirname(called_from)
+        dirname = File.realpath(File.dirname(called_from))
 
         loop do
           basename = File.basename(dirname)
@@ -48,11 +49,13 @@ module RubyNext
 
         GemTranspiler.maybe_transpile(File.dirname(dirname), lib_dir, next_dirname) if transpile
 
-        current_index = $LOAD_PATH.index(dirname)
+        current_index = $LOAD_PATH.find_index do |load_path|
+          Pathname.new(load_path).realpath.to_s == dirname
+        end
 
         raise "Gem's lib is not in the $LOAD_PATH: #{dirname}" if current_index.nil?
 
-        version = RubyNext.next_version
+        version = RubyNext.next_ruby_version
 
         loop do
           break unless version
@@ -64,7 +67,7 @@ module RubyNext
             current_index += 1
           end
 
-          version = RubyNext.next_version(version)
+          version = RubyNext.next_ruby_version(version)
         end
       end
     end

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

@@ -6,3 +6,8 @@ require "parser/current"
 $VERBOSE = save_verbose
 
 require "unparser"
+
+# For backward compatibility with older Unparser
+if RubyNext::Language::Builder.respond_to?(:emit_kwargs=) && !defined?(Unparser::Emitter::Kwargs)
+  RubyNext::Language::Builder.emit_kwargs = false
+end