ruby-next-core 0.2.0

data/lib/ruby-next/core/pattern_matching.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+unless defined?(NoMatchingPatternError)
+  class NoMatchingPatternError < RuntimeError
+  end
+end
+
+# Add `#deconstruct` and `#deconstruct_keys` to core classes
+unless [].respond_to?(:deconstruct)
+  RubyNext.module_eval do
+    refine Array do
+      def deconstruct
+        self
+      end
+    end
+
+    refine Struct do
+      alias deconstruct to_a
+    end
+  end
+end
+
+unless {}.respond_to?(:deconstruct_keys)
+  RubyNext.module_eval do
+    refine Hash do
+      def deconstruct_keys(_)
+        self
+      end
+    end
+
+    refine Struct do
+      def deconstruct_keys(_)
+        to_h
+      end
+    end
+  end
+end

data/lib/ruby-next/core/proc/compose.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# rubocop:disable Style/LambdaCall
+unless proc {}.respond_to?(:<<)
+  RubyNext.module_eval do
+    refine Proc do
+      def <<(other)
+        raise TypeError, "callable object is expected" unless other.respond_to?(:call)
+        this = self
+        proc { |*args, &block| this.(other.(*args, &block)) }
+      end
+
+      def >>(other)
+        raise TypeError, "callable object is expected" unless other.respond_to?(:call)
+        this = self
+        proc { |*args, &block| other.(this.(*args, &block)) }
+      end
+    end
+  end
+end
+# rubocop:enable Style/LambdaCall

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Extend `Language.transform` to inject `using RubyNext` to every file
+RubyNext::Language.singleton_class.prepend(Module.new do
+  def transform(contents, using: true, **hargs)
+    # We cannot activate refinements in eval
+    new_contents = RubyNext::Core.inject!(contents) if using
+    super(new_contents || contents, using: using, **hargs)
+  end
+end)

data/lib/ruby-next/language.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+gem "parser", ">= 2.7.0.0"
+gem "unparser", ">= 0.4.7"
+
+require "set"
+
+require "ruby-next"
+using RubyNext
+
+module RubyNext
+  # Language module contains tools to transpile newer Ruby syntax
+  # into an older one.
+  #
+  # It works the following way:
+  #   - Takes a Ruby source code as input
+  #   - Generates the AST using the edge parser (via the `parser` gem)
+  #   - Pass this AST through the list of processors (one feature = one processor)
+  #   - Each processor may modify the AST
+  #   - Generates a transpiled source code from the transformed AST (via the `unparser` gem)
+  module Language
+    require "ruby-next/language/parser"
+    require "ruby-next/language/unparser"
+
+    class TransformContext
+      attr_reader :versions, :use_ruby_next
+
+      def initialize
+        # Minimum supported RubyNext version
+        @min_version = MIN_SUPPORTED_VERSION
+        @dirty = false
+        @versions = Set.new
+        @use_ruby_next = false
+      end
+
+      # Called by rewriter when it performs transfomrations
+      def track!(rewriter)
+        @dirty = true
+        versions << rewriter.class::MIN_SUPPORTED_VERSION
+      end
+
+      def use_ruby_next!
+        @use_ruby_next = true
+      end
+
+      alias use_ruby_next? use_ruby_next
+
+      def dirty?
+        @dirty == true
+      end
+
+      def min_version
+        versions.min
+      end
+
+      def sorted_versions
+        versions.to_a.sort
+      end
+    end
+
+    class << self
+      attr_accessor :rewriters
+      attr_reader :watch_dirs
+
+      def transform(source, rewriters: self.rewriters, using: true, context: TransformContext.new)
+        parse(source).then do |ast|
+          rewriters.inject(ast) do |tree, rewriter|
+            rewriter.new(context).process(tree)
+          end.then do |new_ast|
+            next source unless context.dirty?
+
+            Unparser.unparse(new_ast)
+          end.then do |source|
+            next source unless using && context.use_ruby_next?
+
+            Core.inject! source.dup
+          end
+        end
+      end
+
+      def transformable?(path)
+        watch_dirs.any? { |dir| path.start_with?(dir) }
+      end
+
+      # Rewriters required for the current version
+      def current_rewriters
+        @current_rewriters ||= rewriters.select(&:unsupported_syntax?)
+      end
+
+      private
+
+      attr_writer :watch_dirs
+    end
+
+    self.rewriters = []
+    self.watch_dirs = %w[app lib spec test].map { |path| File.join(Dir.pwd, path) }
+
+    require "ruby-next/language/rewriters/base"
+
+    require "ruby-next/language/rewriters/endless_range"
+    rewriters << Rewriters::EndlessRange
+
+    require "ruby-next/language/rewriters/pattern_matching"
+    rewriters << Rewriters::PatternMatching
+
+    require "ruby-next/language/rewriters/args_forward"
+    rewriters << Rewriters::ArgsForward
+
+    require "ruby-next/language/rewriters/numbered_params"
+    rewriters << Rewriters::NumberedParams
+
+    if ENV["RUBY_NEXT_ENABLE_METHOD_REFERENCE"] == "1"
+      require "ruby-next/language/rewriters/method_reference"
+      RubyNext::Language.rewriters << RubyNext::Language::Rewriters::MethodReference
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "ruby-next"
+require "ruby-next/utils"
+require "ruby-next/language"
+
+# Patch bootsnap to transform source code.
+# Based on https://github.com/kddeisz/preval/blob/master/lib/preval.rb
+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)
+        return super unless RubyNext::Language.transformable?(path)
+        source = RubyNext::Language.transform(source, rewriters: RubyNext::Language.current_rewriters)
+
+        $stdout.puts ::RubyNext::Utils.source_with_lines(source, path) if ENV["RUBY_NEXT_DEBUG"] == "1"
+
+        RubyVM::InstructionSequence.compile(source, path, path).to_binary
+      rescue SyntaxError
+        raise Bootsnap::CompileCache::Uncompilable, "syntax error"
+      end
+    end
+  )
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module KernelEval
+      refine Kernel do
+        def eval(source, bind = nil, *args)
+          new_source = ::RubyNext::Language::Runtime.transform(
+            source,
+            using: bind&.receiver == TOPLEVEL_BINDING.receiver || bind&.receiver&.is_a?(Module)
+          )
+          $stdout.puts ::RubyNext::Utils.source_with_lines(new_source, "(#{caller_locations(1, 1).first})") if ENV["RUBY_NEXT_DEBUG"] == "1"
+          super new_source, bind, *args
+        end
+      end
+    end
+
+    module InstanceEval # :nodoc:
+      refine Object do
+        def instance_eval(*args, &block)
+          return super(*args, &block) if block_given?
+
+          source = args.shift
+          new_source = ::RubyNext::Language::Runtime.transform(source, using: false)
+          $stdout.puts ::RubyNext::Utils.source_with_lines(new_source, "(#{caller_locations(1, 1).first})") if ENV["RUBY_NEXT_DEBUG"] == "1"
+          super new_source, *args
+        end
+      end
+    end
+
+    module ClassEval
+      refine Module do
+        def module_eval(*args, &block)
+          return super(*args, &block) if block_given?
+
+          source = args.shift
+          new_source = ::RubyNext::Language::Runtime.transform(source, using: false)
+          $stdout.puts ::RubyNext::Utils.source_with_lines(new_source, "(#{caller_locations(1, 1).first})") if ENV["RUBY_NEXT_DEBUG"] == "1"
+          super new_source, *args
+        end
+
+        def class_eval(*args, &block)
+          return super(*args, &block) if block_given?
+
+          source = args.shift
+          new_source = ::RubyNext::Language::Runtime.transform(source, using: false)
+          $stdout.puts ::RubyNext::Utils.source_with_lines(new_source, "(#{caller_locations(1, 1).first})") if ENV["RUBY_NEXT_DEBUG"] == "1"
+          super new_source, *args
+        end
+      end
+    end
+
+    # Refinements for `eval`-like methods.
+    # Transpiling eval is only possible if we do not use local from the binding,
+    # because we cannot access the binding of caller (without non-production ready hacks).
+    #
+    # This module is meant mainly for testing purposes.
+    module Eval
+      include InstanceEval
+      include ClassEval
+      include KernelEval
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# 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)
+      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

@@ -0,0 +1,57 @@
+# 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

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+using RubyNext
+
+module RubyNext
+  module Language
+    module Rewriters
+      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