ruby-next 0.0.1.26 → 0.1.0

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

@@ -0,0 +1,464 @@
+# frozen_string_literal: true
+
+using RubyNext
+
+module RubyNext
+  module Language
+    module Rewriters
+      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 = :__matchee__
+        MATCHEE_ARR = :__matchee_arr__
+        MATCHEE_HASH = :__matchee_hash__
+
+        def on_case_match(node)
+          context.track! self
+          context.use_ruby_next!
+
+          @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
+
+        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)
+          s(:and,
+            case_eq_clause(node.children[0]),
+            match_var_clause(node.children[1], s(:lvar, locals[:matchee])))
+        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
+        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])
+
+          right = s(:send, matchee, :deconstruct)
+
+          deconstructed << locals[:arr]
+          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)))
+        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 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 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 }
+          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
+
+            return dnode if right.nil?
+
+            s(:and,
+              dnode,
+              right)
+          end
+        end
+
+        def hash_pattern_keys(children)
+          return s(:nil) if children.empty?
+
+          children.filter_map do |child|
+            return s(:nil) if child.type == :match_rest
+
+            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
+          return hash_dup if deconstructed.include?(locals[:hash])
+
+          deconstructed << locals[:hash]
+
+          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)),
+              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 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_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
+        end
+
+        def raise_error(type)
+          s(:send, s(:const, nil, :Kernel), :raise,
+            s(:const, nil, type),
+            s(:send,
+              s(:lvar, locals[:matchee]), :inspect))
+        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

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

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+require "ruby-next"
+require "ruby-next/utils"
+require "ruby-next/language"
+
+using RubyNext
+
+module RubyNext
+  module Language
+    # Module responsible for runtime transformations
+    module Runtime
+      # Apply only rewriters required for the current version
+      REWRITERS = RubyNext::Language.rewriters.select(&:unsupported_syntax?)
+
+      class << self
+        include Utils
+
+        attr_reader :watch_dirs
+
+        def load(path, wrap: false)
+          raise "RubyNext cannot handle `load(smth, wrap: true)`" if wrap
+
+          contents = File.read(path)
+          new_contents = transform contents
+
+          puts source_with_lines(new_contents) if ENV["RUBY_NEXT_DEBUG"] == "1"
+
+          TOPLEVEL_BINDING.eval(new_contents, path)
+          true
+        end
+
+        def transform(contents, **options)
+          Language.transform(contents, rewriters: REWRITERS, **options)
+        end
+
+        def transformable?(path)
+          watch_dirs.any? { |dir| path.start_with?(dir) }
+        end
+
+        def feature_path(path)
+          path = resolve_feature_path(path)
+          return if path.nil?
+          return if File.extname(path) != ".rb"
+          return unless transformable?(path)
+          path
+        end
+
+        private
+
+        attr_writer :watch_dirs
+      end
+
+      self.watch_dirs = %w[app lib spec test].map { |path| File.join(Dir.pwd, path) }
+    end
+  end
+end
+
+# Patch Kernel to hijack require/require_relative/load/eval
+module Kernel
+  module_function # rubocop:disable Style/ModuleFunction
+
+  alias_method :require_without_ruby_next, :require
+  def require(path)
+    realpath = RubyNext::Language::Runtime.feature_path(path)
+    return require_without_ruby_next(path) unless realpath
+
+    return false if $LOADED_FEATURES.include?(realpath)
+
+    RubyNext::Language::Runtime.load(realpath)
+
+    $LOADED_FEATURES << realpath
+    true
+  rescue => e
+    warn "RubyNext failed to require '#{path}': #{e.message}"
+    require_without_ruby_next(path)
+  end
+
+  alias_method :require_relative_without_ruby_next, :require_relative
+  def require_relative(path)
+    from = caller_locations(1..1).first.absolute_path || File.join(Dir.pwd, "main")
+    realpath = File.absolute_path(
+      File.join(
+        File.dirname(File.absolute_path(from)),
+        path
+      )
+    )
+    require(realpath)
+  rescue => e
+    warn "RubyNext failed to require relative '#{path}' from #{from}: #{e.message}"
+    require_relative_without_ruby_next(path)
+  end
+
+  alias_method :load_without_ruby_next, :load
+  def load(path, wrap = false)
+    realpath = RubyNext::Language::Runtime.feature_path(path)
+
+    return load_without_ruby_next(path, wrap) unless realpath
+
+    RubyNext::Language::Runtime.load(realpath, wrap: wrap)
+  rescue => e
+    warn "RubyNext failed to load '#{path}': #{e.message}"
+    load_without_ruby_next(path)
+  end
+
+  alias_method :eval_without_ruby_next, :eval
+  def eval(source, *args)
+    new_source = RubyNext::Language::Runtime.transform(source, eval: true)
+    eval_without_ruby_next new_source, *args
+  end
+end
+
+# Patch BasicObject to hijack instance_eval
+class BasicObject
+  alias_method :instance_eval_without_ruby_next, :instance_eval
+
+  def instance_eval(*args, &block)
+    return instance_eval_without_ruby_next(*args, &block) if block_given?
+
+    source = args.shift
+    new_source = ::RubyNext::Language::Runtime.transform(source, eval: true)
+    instance_eval_without_ruby_next new_source, *args
+  end
+end
+
+# Patch Module to hijack class_eval/module_eval
+class Module
+  alias_method :module_eval_without_ruby_next, :module_eval
+
+  def module_eval(*args, &block)
+    return module_eval_without_ruby_next(*args, &block) if block_given?
+
+    source = args.shift
+    new_source = ::RubyNext::Language::Runtime.transform(source, eval: true)
+    module_eval_without_ruby_next new_source, *args
+  end
+
+  alias_method :class_eval_without_ruby_next, :class_eval
+
+  def class_eval(*args, &block)
+    return class_eval_without_ruby_next(*args, &block) if block_given?
+
+    source = args.shift
+    new_source = ::RubyNext::Language::Runtime.transform(source, eval: true)
+    class_eval_without_ruby_next new_source, *args
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# Make sure Core is loaded
+require "ruby-next"
+
+module RubyNext
+  module Language
+    class << self
+      def setup_gem_load_path(lib_dir = "lib", rbnext_dir: RUBY_NEXT_DIR)
+        called_from = caller_locations(1, 1).first.path
+        dirname = File.dirname(called_from)
+
+        loop do
+          basename = File.basename(dirname)
+          raise "Couldn't find gem's load dir: #{lib_dir}" if basename == dirname
+
+          break if basename == lib_dir
+
+          dirname = File.dirname(basename)
+        end
+
+        current_index = $LOAD_PATH.index(dirname)
+
+        raise "Gem's lib is not in the $LOAD_PATH: #{dirname}" if current_index.nil?
+
+        version = RubyNext.next_version
+
+        loop do
+          break unless version
+
+          version_dir = File.join(dirname, rbnext_dir, version.segments[0..1].join("."))
+
+          if File.exist?(version_dir)
+            $LOAD_PATH.insert current_index, version_dir
+            current_index += 1
+          end
+
+          version = RubyNext.next_version(version)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+# Require current parser without warnings
+save_verbose, $VERBOSE = $VERBOSE, nil
+require "parser/current"
+$VERBOSE = save_verbose
+
+require "unparser"
+
+# Unparser patches
+
+# Unparser doesn't support endless ranges
+# Source: https://github.com/mbj/unparser/blob/a4f959d58b660ef0630659efa5882fc20936eb18/lib/unparser/emitter/literal/range.rb
+# TODO: propose a PR
+class Unparser::Emitter::Literal::Range
+  private
+
+  def dispatch
+    visit(begin_node)
+    write(TOKENS.fetch(node.type))
+    visit(end_node) unless end_node.nil?
+  end
+end