ruby-next-core 0.14.0 → 1.0.1

data/lib/.rbnext/2.3/ruby-next/config.rb

@@ -0,0 +1,79 @@
+# 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 => 4
+  }.freeze
+
+  LATEST_VERSION = [3, 4].freeze
+
+  # A virtual version number used for proposed features
+  NEXT_VERSION = "1995.next.0"
+
+  class << self
+    # TruffleRuby claims its RUBY_VERSION to be X.Y while not supporting all the features
+    # Currently (23.0.1), it still doesn't support pattern matching, although claims to be "like 3.1".
+    # So, we fallback to 2.6.5 (since we cannot use 2.7).
+    if defined?(TruffleRuby)
+      def current_ruby_version
+        "2.6.5"
+      end
+    else
+      def current_ruby_version
+        ::RUBY_VERSION
+      end
+    end
+
+    # Returns true if we want to use edge syntax
+    def edge_syntax?
+      %w[y true 1].include?(ENV["RUBY_NEXT_EDGE"])
+    end
+
+    def proposed_syntax?
+      %w[y true 1].include?(ENV["RUBY_NEXT_PROPOSED"])
+    end
+
+    def next_ruby_version(version = current_ruby_version)
+      return if version == Gem::Version.new(NEXT_VERSION)
+
+      major, minor = Gem::Version.new(version).segments.map(&:to_i)
+
+      return Gem::Version.new(NEXT_VERSION) 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
+
+    # Load transpile settings from the RC file (nextify command flags)
+    def load_from_rc(path = ".rbnextrc")
+      return unless File.exist?(path)
+
+      require "yaml"
+
+      args = ((((__safe_lvar__ = ((((__safe_lvar__ = ((((__safe_lvar__ = YAML.load_file(path)) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.fetch("nextify", ""))) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.lines)) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.flat_map { |line|
+  line.chomp.split(/\s+/)
+})
+
+      ENV["RUBY_NEXT_EDGE"] ||= "true" if args.delete("--edge")
+      ENV["RUBY_NEXT_PROPOSED"] ||= "true" if args.delete("--proposed")
+      ENV["RUBY_NEXT_TRANSPILE_MODE"] ||= "rewrite" if args.delete("--transpile-mode=rewrite")
+      ENV["RUBY_NEXT_TRANSPILE_MODE"] ||= "ast" if args.delete("--transpile-mode=ast")
+    end
+  end
+
+  load_from_rc
+end

data/lib/.rbnext/2.3/ruby-next/core/data.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+# The code below originates from https://github.com/saturnflyer/polyfill-data
+
+if !Object.const_defined?(:Data) || !Data.respond_to?(:define)
+
+  # Drop legacy Data class
+  begin
+    Object.send(:remove_const, :Data)
+  rescue
+    nil
+  end
+
+  class Data < Object
+    using RubyNext
+
+    class << self
+      undef_method :new
+      attr_reader :members
+    end
+
+    def self.define(*args, &block)
+      raise ArgumentError if args.any?(/=/)
+      if block
+        mod = Module.new
+        mod.define_singleton_method(:_) do |klass|
+          klass.class_eval(&block)
+        end
+        arity_converter = mod.method(:_)
+      end
+      klass = ::Class.new(self)
+
+      klass.instance_variable_set(:@members, args.map(&:to_sym).freeze)
+
+      klass.define_singleton_method(:new) do |*new_args, **new_kwargs, &block|
+        init_kwargs = if new_args.any?
+          raise ArgumentError, "unknown arguments #{new_args[members.size..-1].join(", ")}" if new_args.size > members.size
+          members.take(new_args.size).zip(new_args).to_h
+        else
+          new_kwargs
+        end
+
+        allocate.tap do |instance|
+          instance.send(:initialize, **init_kwargs, &block)
+        end.freeze
+      end
+
+      class << klass
+        alias_method :[], :new
+        undef_method :define
+      end
+
+      args.each do |arg|
+        if klass.method_defined?(arg)
+          raise ArgumentError, "duplicate member #{arg}"
+        end
+        klass.define_method(arg) do
+          @attributes[arg]
+        end
+      end
+
+      if arity_converter
+        klass.class_eval(&arity_converter)
+      end
+
+      klass
+    end
+
+    def self.inherited(subclass)
+      subclass.instance_variable_set(:@members, members)
+    end
+
+    def members
+      self.class.members
+    end
+
+    def initialize(**kwargs)
+      kwargs_size = kwargs.size
+      members_size = members.size
+
+      if kwargs_size > members_size
+        extras = kwargs.except(*members).keys
+
+        if extras.size > 1
+          raise ArgumentError, "unknown keywords: #{extras.map { |_1| ":#{_1}" }.join(", ")}"
+        else
+          raise ArgumentError, "unknown keyword: :#{extras.first}"
+        end
+      elsif kwargs_size < members_size
+        missing = members.select { |k| !kwargs.include?(k) }
+
+        if missing.size > 1
+          raise ArgumentError, "missing keywords: #{missing.map { |_1| ":#{_1}" }.join(", ")}"
+        else
+          raise ArgumentError, "missing keyword: :#{missing.first}"
+        end
+      end
+
+      @attributes = members.map { |m| [m, kwargs[m]] }.to_h
+    end
+
+    def deconstruct
+      @attributes.values
+    end
+
+    def deconstruct_keys(array)
+      raise TypeError unless array.is_a?(Array) || array.nil?
+      return @attributes if ((((__safe_lvar__ = array) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.first).nil?
+
+      @attributes.slice(*array)
+    end
+
+    def to_h(&block)
+      @attributes.to_h(&block)
+    end
+
+    def hash
+      to_h.hash
+    end
+
+    def eql?(other)
+      self.class == other.class && hash == other.hash
+    end
+
+    def ==(other)
+      self.class == other.class && to_h == other.to_h
+    end
+
+    def inspect
+      attribute_markers = @attributes.map do |key, value|
+        insect_key = key.to_s.start_with?("@") ? ":#{key}" : key
+        "#{insect_key}=#{value}"
+      end.join(", ")
+
+      display = ["data", self.class.name, attribute_markers].compact.join(" ")
+
+      "#<#{display}>"
+    end
+    alias_method :to_s, :inspect
+
+    def with(**kwargs)
+      return self if kwargs.empty?
+
+      self.class.new(**@attributes.merge(kwargs))
+    end
+
+    private
+
+    def marshal_dump
+      @attributes
+    end
+
+    def marshal_load(attributes)
+      @attributes = attributes
+      freeze
+    end
+
+    def initialize_copy(source)
+      super.freeze
+    end
+  end
+
+end

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

@@ -11,7 +11,7 @@ module RubyNext
               using: ((((__safe_lvar__ = bind) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.receiver) == TOPLEVEL_BINDING.receiver || ((((__safe_lvar__ = ((((__safe_lvar__ = bind) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.receiver)) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.is_a?(Module))
             )
             RubyNext.debug_source(new_source, "(#{caller_locations(1, 1).first})")
-            super new_source, bind, *args
+            super(new_source, bind, *args)
           end
         end
       end
@@ -25,7 +25,7 @@ module RubyNext
           source = args.shift
           new_source = ::RubyNext::Language::Runtime.transform(source, using: false)
           RubyNext.debug_source(new_source, "(#{caller_locations(1, 1).first})")
-          super new_source, *args
+          super(new_source, *args)
         end
       end
     end
@@ -39,7 +39,7 @@ module RubyNext
           new_source = ::RubyNext::Language::Runtime.transform(source, using: false)
 
           RubyNext.debug_source(new_source, "(#{caller_locations(1, 1).first})")
-          super new_source, *args
+          super(new_source, *args)
         end
 
         def class_eval(*args, &block)
@@ -48,7 +48,7 @@ module RubyNext
           source = args.shift
           new_source = ::RubyNext::Language::Runtime.transform(source, using: false)
           RubyNext.debug_source(new_source, "(#{caller_locations(1, 1).first})")
-          super new_source, *args
+          super(new_source, *args)
         end
       end
     end

data/lib/.rbnext/2.3/ruby-next/language/rewriters/2.7/args_forward.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class ArgsForward < Base
+        NAME = "args-forward"
+        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_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(farg.loc.expression, "*#{REST}, &#{BLOCK}")
+
+          node.updated(
+            :args,
+            [
+              *node.children.slice(0, node.children.index(farg)),
+              s(:restarg, REST),
+              s(:blockarg, BLOCK)
+            ]
+          )
+        end
+
+        def on_send(node)
+          fargs = extract_fargs(node)
+          return super(node) unless fargs
+
+          process_fargs(node, fargs)
+        end
+
+        def on_super(node)
+          fargs = extract_fargs(node)
+          return super(node) unless fargs
+
+          process_fargs(node, fargs)
+        end
+
+        def on_def(node)
+          return super unless forward_arg?(node.children[1])
+
+          new_node = super
+
+          name = node.children[0]
+
+          insert_after(node.loc.expression, "; respond_to?(:ruby2_keywords, true) && (ruby2_keywords :#{name})")
+
+          s(:begin,
+            new_node,
+            ruby2_keywords_node(nil, name))
+        end
+
+        def on_defs(node)
+          return super unless forward_arg?(node.children[2])
+
+          new_node = super
+
+          receiver = node.children[0]
+          name = node.children[1]
+
+          # Using self.ruby2_keywords :name results in undefined method error,
+          # singleton_class works as expected
+          receiver = s(:send, nil, :singleton_class) if receiver.type == :self
+
+          receiver_name =
+            case receiver.type
+            when :send
+              receiver.children[1]
+            when :const
+              receiver.children[1]
+            end
+
+          insert_after(node.loc.expression, "; #{receiver_name}.respond_to?(:ruby2_keywords, true) && (#{receiver_name}.send(:ruby2_keywords, :#{name}))")
+
+          s(:begin,
+            new_node,
+            ruby2_keywords_node(receiver, name))
+        end
+
+        private
+
+        def ruby2_keywords_node(receiver, name)
+          s(:and,
+            s(:send, receiver, :respond_to?,
+              s(:sym, :ruby2_keywords), s(:true)),
+            s(:begin,
+              s(:send, receiver, :send,
+                s(:sym, :ruby2_keywords),
+                s(:sym, name))))
+        end
+
+        def forward_arg?(args)
+          return false unless ((((__safe_lvar__ = args) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.children)
+
+          args.children.any? { |arg| arg.type == :forward_arg }
+        end
+
+        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}")
+
+          process(
+            node.updated(
+              nil,
+              [
+                *node.children.take(node.children.index(fargs)),
+                *forwarded_args
+              ]
+            )
+          )
+        end
+
+        def forwarded_args
+          [
+            s(:splat, s(:lvar, REST)),
+            s(:block_pass, s(:lvar, BLOCK))
+          ]
+        end
+      end
+    end
+  end
+end