ruby-next 0.3.0 → 0.4.0

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

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require "parser/ruby27"
-
-module RubyNext
-  module Language
-    class Builder < ::Parser::Builders::Default
-      modernize
-    end
-
-    class << self
-      def parser
-        ::Parser::Ruby27.new(Builder.new).tap do |prs|
-          prs.diagnostics.tap do |diagnostics|
-            diagnostics.all_errors_are_fatal = true
-          end
-        end
-      end
-
-      def parse(source, file = "(string)")
-        buffer = ::Parser::Source::Buffer.new(file).tap do |buffer|
-          buffer.source = source
-        end
-        parser.parse(buffer)
-      end
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module RubyNext
-  module Language
-    module Rewriters
-      class ArgsForward < Base
-        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_args(node)
-          context.track! self
-
-          node.updated(
-            :args,
-            [
-              s(:restarg, REST),
-              s(:blockarg, BLOCK)
-            ]
-          )
-        end
-
-        def on_send(node)
-          return unless node.children[2]&.type == :forwarded_args
-
-          node.updated(
-            nil,
-            [
-              *node.children[0..1],
-              *forwarded_args
-            ]
-          )
-        end
-
-        def on_super(node)
-          return unless node.children[0]&.type == :forwarded_args
-
-          node.updated(
-            nil,
-            forwarded_args
-          )
-        end
-
-        private
-
-        def forwarded_args
-          [
-            s(:splat, s(:lvar, REST)),
-            s(:block_pass, s(:lvar, BLOCK))
-          ]
-        end
-      end
-    end
-  end
-end

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

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-module RubyNext
-  module Language
-    module Rewriters
-      using RubyNext
-
-      CUSTOM_PARSER_REQUIRED = <<~MSG
-        The %s feature is not a part of the latest stable Ruby release
-        and is not supported by your Parser gem version.
-
-        Use RubyNext's parser to use it: https://github.com/ruby-next/parser
-
-      MSG
-
-      class Base < ::Parser::TreeRewriter
-        class LocalsTracker
-          attr_reader :stacks
-
-          def initialize
-            @stacks = []
-          end
-
-          def with(**locals)
-            stacks << locals
-            yield.tap { stacks.pop }
-          end
-
-          def [](name, suffix = nil)
-            fetch(name).then do |name|
-              next name unless suffix
-              :"#{name}#{suffix}__"
-            end
-          end
-
-          def key?(name)
-            !!fetch(name) { false }
-          end
-
-          def fetch(name)
-            ind = -1
-
-            loop do
-              break stacks[ind][name] if stacks[ind].key?(name)
-              ind -= 1
-              break if stacks[ind].nil?
-            end.then do |name|
-              next name unless name.nil?
-
-              return yield if block_given?
-              raise ArgumentError, "Local var not found in scope: #{name}"
-            end
-          end
-        end
-
-        class << self
-          # Returns true if the syntax is supported
-          # by the current Ruby (performs syntax check, not version check)
-          def unsupported_syntax?
-            save_verbose, $VERBOSE = $VERBOSE, nil
-            eval_mid = Kernel.respond_to?(:eval_without_ruby_next) ? :eval_without_ruby_next : :eval
-            Kernel.send eval_mid, self::SYNTAX_PROBE
-            false
-          rescue SyntaxError, NameError
-            true
-          ensure
-            $VERBOSE = save_verbose
-          end
-
-          # Returns true if the syntax is supported
-          # by the specified version
-          def unsupported_version?(version)
-            self::MIN_SUPPORTED_VERSION > version
-          end
-
-          private
-
-          def transform(source)
-            Language.transform(source, rewriters: [self], using: false)
-          end
-
-          def warn_custom_parser_required_for(feature)
-            warn(CUSTOM_PARSER_REQUIRED % feature)
-          end
-        end
-
-        attr_reader :locals
-
-        def initialize(context)
-          @context = context
-          @locals = LocalsTracker.new
-          super()
-        end
-
-        def s(type, *children)
-          ::Parser::AST::Node.new(type, children)
-        end
-
-        private
-
-        attr_reader :context
-      end
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-module RubyNext
-  module Language
-    module Rewriters
-      class EndlessRange < Base
-        SYNTAX_PROBE = "[0, 1][1..]"
-        MIN_SUPPORTED_VERSION = Gem::Version.new("2.6.0")
-
-        def on_index(node)
-          @current_index = node
-          new_index = process(node.children.last)
-          return unless new_index != node.children.last
-
-          node.updated(
-            nil,
-            [
-              node.children.first,
-              new_index
-            ]
-          )
-        end
-
-        def on_erange(node)
-          return unless node.children.last.nil?
-
-          context.track! self
-
-          new_end =
-            if index_arg?(node)
-              s(:int, -1)
-            else
-              s(:const,
-                s(:const,
-                  s(:cbase), :Float),
-                :INFINITY)
-            end
-
-          node.updated(
-            :irange,
-            [
-              node.children.first,
-              new_end
-            ]
-          )
-        end
-
-        alias_method :on_irange, :on_erange
-
-        private
-
-        attr_reader :current_index
-
-        def index_arg?(node)
-          current_index&.children&.include?(node)
-        end
-      end
-    end
-  end
-end

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

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module RubyNext
-  module Language
-    module Rewriters
-      class MethodReference < Base
-        SYNTAX_PROBE = "Language.:transform"
-        MIN_SUPPORTED_VERSION = Gem::Version.new("2.7.0")
-
-        def on_meth_ref(node)
-          context.track! self
-
-          receiver, mid = *node.children
-
-          node.updated(
-            :send,
-            [
-              receiver,
-              :method,
-              s(:sym, mid)
-            ]
-          )
-        end
-
-        begin
-          transform(SYNTAX_PROBE)
-        rescue ::Parser::SyntaxError
-          warn_custom_parser_required_for("method reference")
-        end
-      end
-    end
-  end
-end

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

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module RubyNext
-  module Language
-    module Rewriters
-      class NumberedParams < Base
-        using RubyNext
-
-        SYNTAX_PROBE = "proc { _1 }.call(1)"
-        MIN_SUPPORTED_VERSION = Gem::Version.new("2.7.0")
-
-        def on_numblock(node)
-          context.track! self
-
-          proc_or_lambda, num, *rest = *node.children
-
-          node.updated(
-            :block,
-            [
-              proc_or_lambda,
-              proc_args(num),
-              *rest
-            ]
-          )
-        end
-
-        private
-
-        def proc_args(n)
-          return s(:args, s(:procarg0, s(:arg, :_1))) if n == 1
-
-          (1..n).map do |numero|
-            s(:arg, :"_#{numero}")
-          end.then do |args|
-            s(:args, *args)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,541 +0,0 @@
-# frozen_string_literal: true
-
-module RubyNext
-  module Language
-    module Rewriters
-      using RubyNext
-
-      using(Module.new do
-        refine ::Parser::AST::Node do
-          def to_ast_node
-            self
-          end
-        end
-
-        refine String do
-          def to_ast_node
-            ::Parser::AST::Node.new(:str, [self])
-          end
-        end
-
-        refine Symbol do
-          def to_ast_node
-            ::Parser::AST::Node.new(:sym, [self])
-          end
-        end
-
-        refine Integer do
-          def to_ast_node
-            ::Parser::AST::Node.new(:int, [self])
-          end
-        end
-      end)
-
-      class PatternMatching < Base
-        SYNTAX_PROBE = "case 0; in 0; true; else; 1; end"
-        MIN_SUPPORTED_VERSION = Gem::Version.new("2.7.0")
-
-        MATCHEE = :__m__
-        MATCHEE_ARR = :__m_arr__
-        MATCHEE_HASH = :__m_hash__
-
-        def on_case_match(node)
-          context.track! self
-
-          @deconstructed = []
-
-          matchee_ast =
-            s(:lvasgn, MATCHEE, node.children[0])
-
-          ifs_ast = locals.with(
-            matchee: MATCHEE,
-            arr: MATCHEE_ARR,
-            hash: MATCHEE_HASH
-          ) do
-            build_if_clause(node.children[1], node.children[2..-1])
-          end
-
-          node.updated(
-            :begin,
-            [
-              matchee_ast, ifs_ast
-            ]
-          )
-        end
-
-        def on_in_match(node)
-          context.track! self
-
-          matchee =
-            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]
-              ).then do |node|
-                s(:or,
-                  node,
-                  no_matching_pattern)
-              end
-            end
-
-          node.updated(
-            :and,
-            [
-              matchee,
-              pattern
-            ]
-          )
-        end
-
-        private
-
-        def build_if_clause(node, rest)
-          if node&.type == :in_pattern
-            build_in_pattern(node, rest)
-          else
-            raise "Unexpected else in the middle of case ... in" if rest && rest.size > 0
-            # else clause must be present
-            node || no_matching_pattern
-          end
-        end
-
-        def build_in_pattern(clause, rest)
-          [
-            with_guard(
-              send(
-                :"#{clause.children[0].type}_clause",
-                clause.children[0]
-              ),
-              clause.children[1] # guard
-            ),
-            clause.children[2] || s(:nil) # expression
-          ].then do |children|
-            if rest && rest.size > 0
-              children << build_if_clause(rest.first, rest[1..-1])
-            end
-
-            s(:if, *children)
-          end
-        end
-
-        def const_pattern_clause(node)
-          const, pattern = *node.children
-
-          case_eq_clause(const).then do |node|
-            next node if pattern.nil?
-
-            s(:and,
-              node,
-              send(:"#{pattern.type}_clause", pattern))
-          end
-        end
-
-        def match_alt_clause(node)
-          children = node.children.map do |child|
-            send :"#{child.type}_clause", child
-          end
-          s(:or, *children)
-        end
-
-        def match_as_clause(node, right = s(:lvar, locals[:matchee]))
-          s(:and,
-            case_eq_clause(node.children[0]),
-            match_var_clause(node.children[1], right))
-        end
-
-        def match_var_clause(node, left = s(:lvar, locals[:matchee]))
-          s(:or,
-            s(:lvasgn, node.children[0], left),
-            s(:true)) # rubocop:disable Lint/BooleanSymbol
-        end
-
-        def pin_clause(node)
-          case_eq_clause node.children[0]
-        end
-
-        def case_eq_clause(node, right = s(:lvar, locals[:matchee]))
-          s(:send,
-            node, :===, right)
-        end
-
-        #=========== ARRAY PATTERN (START) ===============
-
-        def array_pattern_clause(node, matchee = s(:lvar, locals[:matchee]))
-          deconstruct_node(matchee).then do |dnode|
-            right =
-              if node.children.empty?
-                case_eq_clause(s(:array), s(:lvar, locals[:arr]))
-              else
-                array_element(0, *node.children)
-              end
-
-            # already deconsrtructed
-            next right if dnode.nil?
-
-            # if there is no rest or tail, match the size first
-            unless node.type == :array_pattern_with_tail || node.children.any? { |n| n.type == :match_rest }
-              right =
-                s(:and,
-                  s(:send,
-                    node.children.size.to_ast_node,
-                    :==,
-                    s(:send, s(:lvar, locals[:arr]), :size)),
-                  right)
-            end
-
-            s(:and,
-              dnode,
-              right)
-          end.then do |right|
-            s(:and,
-              respond_to_check(matchee, :deconstruct),
-              right)
-          end
-        end
-
-        alias array_pattern_with_tail_clause array_pattern_clause
-
-        def deconstruct_node(matchee)
-          # only deconstruct once per case
-          return if deconstructed&.include?(locals[:arr])
-
-          context.use_ruby_next!
-
-          right = s(:send, matchee, :deconstruct)
-
-          deconstructed << locals[:arr] if deconstructed
-
-          s(:and,
-            s(:or,
-              s(:lvasgn, locals[:arr], right),
-              s(:true)), # rubocop:disable Lint/BooleanSymbol
-            s(:or,
-              case_eq_clause(s(:const, nil, :Array), s(:lvar, locals[:arr])),
-              raise_error(:TypeError, "#deconstruct must return Array")))
-        end
-
-        def array_element(index, head, *tail)
-          return array_match_rest(index, head, *tail) if head.type == :match_rest
-
-          send("#{head.type}_array_element", head, index).then do |node|
-            next node if tail.empty?
-
-            s(:and,
-              node,
-              array_element(index + 1, *tail))
-          end
-        end
-
-        def array_match_rest(index, node, *tail)
-          child = node.children[0]
-          rest = arr_rest_items(index, tail.size).then do |r|
-            next r unless child
-            match_var_clause(
-              child,
-              r
-            )
-          end
-
-          return rest if tail.empty?
-
-          s(:and,
-            rest,
-            array_rest_element(*tail))
-        end
-
-        def array_rest_element(head, *tail)
-          send("#{head.type}_array_element", head, -(tail.size + 1)).then do |node|
-            next node if tail.empty?
-
-            s(:and,
-              node,
-              array_rest_element(*tail))
-          end
-        end
-
-        def array_pattern_array_element(node, index)
-          element = arr_item_at(index)
-          locals.with(arr: locals[:arr, index]) do
-            array_pattern_clause(node, element)
-          end
-        end
-
-        def hash_pattern_array_element(node, index)
-          element = arr_item_at(index)
-          locals.with(hash: locals[:arr, index]) do
-            hash_pattern_clause(node, element)
-          end
-        end
-
-        def match_alt_array_element(node, index)
-          children = node.children.map do |child, i|
-            send :"#{child.type}_array_element", child, index
-          end
-          s(:or, *children)
-        end
-
-        def match_var_array_element(node, index)
-          match_var_clause(node, arr_item_at(index))
-        end
-
-        def match_as_array_element(node, index)
-          match_as_clause(node, arr_item_at(index))
-        end
-
-        def pin_array_element(node, index)
-          case_eq_array_element node.children[0], index
-        end
-
-        def case_eq_array_element(node, index)
-          case_eq_clause(node, arr_item_at(index))
-        end
-
-        def arr_item_at(index, arr = s(:lvar, locals[:arr]))
-          s(:index, arr, index.to_ast_node)
-        end
-
-        def arr_rest_items(index, size, arr = s(:lvar, locals[:arr]))
-          s(:index,
-            arr,
-            s(:irange,
-              s(:int, index),
-              s(:int, -(size + 1))))
-        end
-
-        #=========== ARRAY PATTERN (END) ===============
-
-        #=========== HASH PATTERN (START) ===============
-
-        def hash_pattern_clause(node, matchee = s(:lvar, locals[:matchee]))
-          # Optimization: avoid hash modifications when not needed
-          # (we use #dup and #delete when "reading" values when **rest is present
-          # to assign the rest of the hash copy to it)
-          @hash_match_rest = node.children.any? { |child| child.type == :match_rest || child.type == :match_nil_pattern }
-          keys = hash_pattern_keys(node.children)
-
-          deconstruct_keys_node(keys, matchee).then do |dnode|
-            right =
-              if node.children.empty?
-                case_eq_clause(s(:hash), s(:lvar, locals[:hash]))
-              else
-                hash_element(*node.children)
-              end
-
-            next dnode if right.nil?
-
-            s(:and,
-              dnode,
-              right)
-          end.then do |right|
-            s(:and,
-              respond_to_check(matchee, :deconstruct_keys),
-              right)
-          end
-        end
-
-        def hash_pattern_keys(children)
-          return s(:nil) if children.empty?
-
-          children.filter_map do |child|
-            # Skip ** without var
-            next if child.type == :match_rest && child.children.empty?
-            return s(:nil) if child.type == :match_rest || child.type == :match_nil_pattern
-
-            send("#{child.type}_hash_key", child)
-          end.then { |keys| s(:array, *keys) }
-        end
-
-        def pair_hash_key(node)
-          node.children[0]
-        end
-
-        def match_var_hash_key(node)
-          s(:sym, node.children[0])
-        end
-
-        def deconstruct_keys_node(keys, matchee = s(:lvar, locals[:matchee]))
-          # Deconstruct once and use a copy of the hash for each pattern if we need **rest.
-          hash_dup =
-            if @hash_match_rest
-              s(:lvasgn, locals[:hash], s(:send, s(:lvar, locals[:hash, :src]), :dup))
-            else
-              s(:lvasgn, locals[:hash], s(:lvar, locals[:hash, :src]))
-            end
-
-          # Create a copy of the original hash if already deconstructed
-          # FIXME: need better algorithm to handle different key sets
-          # return hash_dup if deconstructed&.include?(locals[:hash])
-
-          context.use_ruby_next!
-
-          deconstructed << locals[:hash] if deconstructed
-
-          right = s(:send,
-            matchee, :deconstruct_keys, keys)
-
-          s(:and,
-            s(:or,
-              s(:lvasgn, locals[:hash, :src], right),
-              s(:true)), # rubocop:disable Lint/BooleanSymbol
-            s(:and,
-              s(:or,
-                case_eq_clause(s(:const, nil, :Hash), s(:lvar, locals[:hash, :src])),
-                raise_error(:TypeError, "#deconstruct_keys must return Hash")),
-              hash_dup))
-        end
-
-        def hash_pattern_hash_element(node, key)
-          element = hash_value_at(key)
-          locals.with(hash: locals[:hash, deconstructed.size]) do
-            hash_pattern_clause(node, element)
-          end
-        end
-
-        def array_pattern_hash_element(node, key)
-          element = hash_value_at(key)
-          locals.with(arr: locals[:hash, deconstructed.size]) do
-            array_pattern_clause(node, element)
-          end
-        end
-
-        def hash_element(head, *tail)
-          send("#{head.type}_hash_element", head).then do |node|
-            next node if tail.empty?
-
-            right = hash_element(*tail)
-
-            next node if right.nil?
-
-            s(:and,
-              node,
-              right)
-          end
-        end
-
-        def pair_hash_element(node, _key = nil)
-          key, val = *node.children
-          send("#{val.type}_hash_element", val, key)
-        end
-
-        def match_alt_hash_element(node, key)
-          element_node = s(:lvasgn, locals[:hash, :el], hash_value_at(key))
-
-          children = locals.with(hash_element: locals[:hash, :el]) do
-            node.children.map do |child, i|
-              send :"#{child.type}_hash_element", child, key
-            end
-          end
-
-          s(:and,
-            s(:or,
-              element_node,
-              s(:true)), # rubocop:disable Lint/BooleanSymbol
-            s(:or, *children))
-        end
-
-        def match_var_hash_element(node, key = nil)
-          key ||= node.children[0]
-          # We need to check whether key is present first
-          s(:and,
-            hash_has_key(key),
-            match_var_clause(node, hash_value_at(key)))
-        end
-
-        def match_nil_pattern_hash_element(node, _key = nil)
-          s(:send,
-            s(:lvar, locals[:hash]),
-            :empty?)
-        end
-
-        def match_rest_hash_element(node, _key = nil)
-          # case {}; in **; end
-          return if node.children.empty?
-
-          child = node.children[0]
-
-          raise ArgumentError, "Unknown hash match_rest child: #{child.type}" unless child.type == :match_var
-
-          match_var_clause(child, s(:lvar, locals[:hash]))
-        end
-
-        def case_eq_hash_element(node, key)
-          case_eq_clause node, hash_value_at(key)
-        end
-
-        def hash_value_at(key, hash = s(:lvar, locals[:hash]))
-          return s(:lvar, locals.fetch(:hash_element)) if locals.key?(:hash_element)
-
-          if @hash_match_rest
-            s(:send,
-              hash, :delete,
-              key.to_ast_node)
-          else
-            s(:index,
-              hash,
-              key.to_ast_node)
-          end
-        end
-
-        def hash_has_key(key, hash = s(:lvar, locals[:hash]))
-          s(:send,
-            hash, :key?,
-            key.to_ast_node)
-        end
-
-        #=========== HASH PATTERN (END) ===============
-
-        def with_guard(node, guard)
-          return node unless guard
-
-          s(:and,
-            node,
-            guard.children[0]).then do |expr|
-            next expr unless guard.type == :unless_guard
-            s(:send, expr, :!)
-          end
-        end
-
-        def no_matching_pattern
-          raise_error(
-            :NoMatchingPatternError,
-            s(:send,
-              s(:lvar, locals[:matchee]), :inspect)
-          )
-        end
-
-        def raise_error(type, msg = "")
-          s(:send, s(:const, nil, :Kernel), :raise,
-            s(:const, nil, type),
-            msg.to_ast_node)
-        end
-
-        def respond_to_check(node, mid)
-          s(:send, node, :respond_to?, mid.to_ast_node)
-        end
-
-        def respond_to_missing?(mid, *)
-          return true if mid.match?(/_(clause|array_element)/)
-          super
-        end
-
-        def method_missing(mid, *args, &block)
-          return case_eq_clause(args.first) if mid.match?(/_clause$/)
-          return case_eq_array_element(*args) if mid.match?(/_array_element$/)
-          return case_eq_hash_element(*args) if mid.match?(/_hash_element$/)
-          super
-        end
-
-        private
-
-        attr_reader :deconstructed
-      end
-    end
-  end
-end