ruby-next-core 0.14.0 → 1.0.1

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

@@ -182,11 +182,10 @@ module RubyNext
           end
         end
 
-        # rubocop:disable Style/MethodMissingSuper
         # rubocop:disable Style/MissingRespondToMissing
         class Noop < Base
           # Return node itself, no memoization
-          def method_missing(mid, node, *)
+          def method_missing(mid, node, *__rest__)
             node
           end
         end
@@ -243,6 +242,7 @@ module RubyNext
 
           @deconstructed_keys = {}
           @predicates = Predicates::CaseIn.new
+          @lvars = []
 
           matchee_ast =
             s(:begin, s(:lvasgn, MATCHEE, node.children[0]))
@@ -272,6 +272,7 @@ module RubyNext
 
           @deconstructed_keys = {}
           @predicates = Predicates::Noop.new
+          @lvars = []
 
           matchee =
             s(:begin, s(:lvasgn, MATCHEE, node.children[0]))
@@ -282,10 +283,12 @@ module RubyNext
               arr: MATCHEE_ARR,
               hash: MATCHEE_HASH
             ) do
-              send(
-                :"#{node.children[1].type}_clause",
-                node.children[1]
-              ).then do |node|
+              with_declared_locals do
+                send(
+                  :"#{node.children[1].type}_clause",
+                  node.children[1]
+                )
+              end.then do |node|
                 s(:begin,
                   s(:or,
                     node,
@@ -311,6 +314,7 @@ module RubyNext
 
           @deconstructed_keys = {}
           @predicates = Predicates::Noop.new
+          @lvars = []
 
           matchee =
             s(:begin, s(:lvasgn, MATCHEE, node.children[0]))
@@ -321,10 +325,12 @@ module RubyNext
               arr: MATCHEE_ARR,
               hash: MATCHEE_HASH
             ) do
-              send(
-                :"#{node.children[1].type}_clause",
-                node.children[1]
-              )
+              with_declared_locals do
+                send(
+                  :"#{node.children[1].type}_clause",
+                  node.children[1]
+                )
+              end
             end
 
           node.updated(
@@ -395,13 +401,15 @@ module RubyNext
         def build_when_clause(clause)
           predicates.reset!
           [
-            with_guard(
-              send(
-                :"#{clause.children[0].type}_clause",
-                clause.children[0]
-              ),
-              clause.children[1] # guard
-            ),
+            with_declared_locals do
+              with_guard(
+                send(
+                  :"#{clause.children[0].type}_clause",
+                  clause.children[0]
+                ),
+                clause.children[1] # guard
+              )
+            end,
             process(clause.children[2] || s(:nil)) # expression
           ].then do |children|
             s(:when, *children)
@@ -417,15 +425,15 @@ module RubyNext
             s(:begin,
               s(:and,
                 node,
-                send(:"#{pattern.type}_clause", pattern)))
+                send(:"#{pattern.type}_clause", pattern, right)))
           end
         end
 
-        def match_alt_clause(node)
+        def match_alt_clause(node, matchee = s(:lvar, locals[:matchee]))
           children = locals.with(ALTERNATION_MARKER => true) do
             node.children.map.with_index do |child, i|
               predicates.terminate! if i == 1
-              send :"#{child.type}_clause", child
+              send :"#{child.type}_clause", child, matchee
             end
           end
           s(:begin, s(:or, *children))
@@ -442,7 +450,7 @@ module RubyNext
           var = node.children[0]
           return s(:true) if var == :_
 
-          check_match_var_alternation!(var) unless var.is_a?(::Parser::AST::Node)
+          check_match_var_alternation!(var)
 
           s(:begin,
             s(:or,
@@ -541,11 +549,10 @@ module RubyNext
         def array_find(head, *nodes, tail)
           index = s(:lvar, :__i__)
 
-          match_vars = []
-
           head_match =
             unless head.children.empty?
-              match_vars << build_var_assignment(head.children[0].children[0])
+              # we only need to call this to track the lvar usage
+              build_var_assignment(head.children[0].children[0])
 
               arr_take = s(:send,
                 s(:lvar, locals[:arr]),
@@ -557,16 +564,19 @@ module RubyNext
 
           tail_match =
             unless tail.children.empty?
-              match_vars << build_var_assignment(tail.children[0].children[0])
+              # we only need to call this to track the lvar usage
+              build_var_assignment(tail.children[0].children[0])
 
               match_var_clause(tail.children[0], arr_slice(index + nodes.size, -1))
             end
 
           nodes.each do |node|
             if node.type == :match_var
-              match_vars << build_var_assignment(node.children[0])
+              # we only need to call this to track the lvar usage
+              build_var_assignment(node.children[0])
             elsif node.type == :match_as
-              match_vars << build_var_assignment(node.children[1].children[0])
+              # we only need to call this to track the lvar usage
+              build_var_assignment(node.children[1].children[0])
             end
           end
 
@@ -594,19 +604,7 @@ module RubyNext
             s(:args,
               s(:arg, :_),
               s(:arg, :__i__)),
-            pattern).then do |block|
-            next block if match_vars.empty?
-
-            # We need to declare match vars outside of `find` block
-            locals_declare = s(:begin, s(:masgn,
-              s(:mlhs, *match_vars),
-              s(:nil)))
-
-            s(:begin,
-              s(:or,
-                locals_declare,
-                block))
-          end
+            pattern)
         end
 
         def array_match_rest(index, node, *tail)
@@ -649,6 +647,14 @@ module RubyNext
           end
         end
 
+        def find_pattern_array_element(node, index)
+          element = arr_item_at(index)
+          locals.with(arr: locals[:arr, index]) do
+            predicates.push :"i#{index}"
+            find_pattern_clause(node, element).tap { predicates.pop }
+          end
+        end
+
         def hash_pattern_array_element(node, index)
           element = arr_item_at(index)
           locals.with(hash: locals[:arr, index]) do
@@ -657,6 +663,14 @@ module RubyNext
           end
         end
 
+        def const_pattern_array_element(node, index)
+          element = arr_item_at(index)
+          locals.with(arr: locals[:arr, index]) do
+            predicates.push :"i#{index}"
+            const_pattern_clause(node, element).tap { predicates.pop }
+          end
+        end
+
         def match_alt_array_element(node, index)
           children = node.children.map do |child, i|
             send :"#{child.type}_array_element", child, index
@@ -665,11 +679,19 @@ module RubyNext
         end
 
         def match_var_array_element(node, index)
-          match_var_clause(node, arr_item_at(index))
+          element = arr_item_at(index)
+          locals.with(arr: locals[:arr, index]) do
+            predicates.push :"i#{index}"
+            match_var_clause(node, element).tap { predicates.pop }
+          end
         end
 
         def match_as_array_element(node, index)
-          match_as_clause(node, arr_item_at(index))
+          element = arr_item_at(index)
+          locals.with(arr: locals[:arr, index]) do
+            predicates.push :"i#{index}"
+            match_as_clause(node, element).tap { predicates.pop }
+          end
         end
 
         def pin_array_element(node, index)
@@ -829,6 +851,24 @@ module RubyNext
           end
         end
 
+        def find_pattern_hash_element(node, key)
+          element = hash_value_at(key)
+          key_index = deconstructed_key(key)
+          locals.with(arr: locals[:hash, key_index]) do
+            predicates.push :"k#{key_index}"
+            find_pattern_clause(node, element).tap { predicates.pop }
+          end
+        end
+
+        def const_pattern_hash_element(node, key)
+          element = hash_value_at(key)
+          key_index = deconstructed_key(key)
+          locals.with(hash: locals[:hash, key_index]) do
+            predicates.push :"k#{key_index}"
+            const_pattern_clause(node, element).tap { predicates.pop }
+          end
+        end
+
         def hash_element(head, *tail)
           send("#{head.type}_hash_element", head).then do |node|
             next node if tail.empty?
@@ -869,12 +909,22 @@ module RubyNext
         end
 
         def match_as_hash_element(node, key)
-          match_as_clause(node, hash_value_at(key))
+          element = hash_value_at(key)
+          key_index = deconstructed_key(key)
+          locals.with(hash: locals[:hash, key_index]) do
+            predicates.push :"k#{key_index}"
+            match_as_clause(node, element).tap { predicates.pop }
+          end
         end
 
         def match_var_hash_element(node, key = nil)
           key ||= node.children[0]
-          match_var_clause(node, hash_value_at(key))
+          element = hash_value_at(key)
+          key_index = deconstructed_key(key)
+          locals.with(hash: locals[:hash, key_index]) do
+            predicates.push :"k#{key_index}"
+            match_var_clause(node, element).tap { predicates.pop }
+          end
         end
 
         def match_nil_pattern_hash_element(node, _key = nil)
@@ -948,6 +998,24 @@ module RubyNext
           end
         end
 
+        def with_declared_locals
+          lvars.clear
+          node = yield
+
+          return node if lvars.empty?
+
+          # We need to declare match lvars outside of the outer `find` block,
+          # so we do that for that whole pattern
+          locals_declare = s(:begin, s(:masgn,
+            s(:mlhs, *lvars.uniq.map { |_1| s(:lvasgn, _1) }),
+            s(:nil)))
+
+          s(:begin,
+            s(:or,
+              locals_declare,
+              node))
+        end
+
         def no_matching_pattern
           raise_error(
             :NoMatchingPatternError,
@@ -967,7 +1035,7 @@ module RubyNext
           s(:send, node, :respond_to?, mid.to_ast_node)
         end
 
-        def respond_to_missing?(mid, *)
+        def respond_to_missing?(mid, *__rest__)
           return true if mid.to_s.match?(/_(clause|array_element)/)
           super
         end
@@ -982,13 +1050,17 @@ module RubyNext
 
         private
 
-        attr_reader :deconstructed_keys, :predicates
+        attr_reader :deconstructed_keys, :predicates, :lvars
 
         # Raise SyntaxError if match-var is used within alternation
         # https://github.com/ruby/ruby/blob/672213ef1ca2b71312084057e27580b340438796/compile.c#L5900
         def check_match_var_alternation!(name)
           return unless locals.key?(ALTERNATION_MARKER)
 
+          if name.is_a?(::Parser::AST::Node)
+            raise ::SyntaxError, "illegal variable in alternative pattern (#{name.children.first})"
+          end
+
           return if name.start_with?("_")
 
           raise ::SyntaxError, "illegal variable in alternative pattern (#{name})"
@@ -1008,7 +1080,10 @@ module RubyNext
 
         # Value could be omitted for mass assignment
         def build_var_assignment(var, value = nil)
-          return s(:lvasgn, *[var, value].compact) unless var.is_a?(::Parser::AST::Node)
+          unless var.is_a?(::Parser::AST::Node)
+            lvars << var
+            return s(:lvasgn, *[var, value].compact)
+          end
 
           asign_type = :"#{var.type.to_s[0]}vasgn"
 

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

@@ -12,7 +12,7 @@ module RubyNext
 
       MSG
 
-      class Base < ::Parser::TreeRewriter
+      class Base < Abstract
         class LocalsTracker
           using(Module.new do
             refine ::Parser::AST::Node do
@@ -64,39 +64,15 @@ module RubyNext
           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, nil, __FILE__, __LINE__
-            false
-          rescue SyntaxError, StandardError
-            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
+        attr_reader :locals
 
-          def transform(source)
-            Language.transform(source, rewriters: [self], using: false)
-          end
+        def self.ast?
+          true
         end
 
-        attr_reader :locals
-
-        def initialize(context)
-          @context = context
+        def initialize(*args)
           @locals = LocalsTracker.new
-          super()
+          super
         end
 
         def s(type, *children)
@@ -144,8 +120,6 @@ module RubyNext
 
           Unparser.unparse(ast).chomp
         end
-
-        attr_reader :context
       end
     end
   end

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

@@ -4,28 +4,6 @@ module RubyNext
   module Utils
     module_function
 
-    if $LOAD_PATH.respond_to?(:resolve_feature_path)
-      def resolve_feature_path(feature)
-        ((((__safe_lvar__ = $LOAD_PATH.resolve_feature_path(feature)) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.last)
-      rescue LoadError
-      end
-    else
-      def resolve_feature_path(path)
-        if File.file?(relative = File.expand_path(path))
-          path = relative
-        end
-
-        path = "#{path}.rb" if File.extname(path).empty?
-
-        return path if Pathname.new(path).absolute?
-
-        $LOAD_PATH.find do |lp|
-          lpath = File.join(lp, path)
-          return File.realpath(lpath) if File.file?(lpath)
-        end
-      end
-    end
-
     def source_with_lines(source, path)
       source.lines.map.with_index do |line, i|
         "#{(i + 1).to_s.rjust(4)}:  #{line}"
@@ -36,6 +14,7 @@ module RubyNext
 
     # Returns true if modules refinement is supported in current version
     def refine_modules?
+      save_verbose, $VERBOSE = $VERBOSE, nil
       @refine_modules ||=
         begin
           # Make sure that including modules within refinements works
@@ -59,6 +38,8 @@ module RubyNext
           true
         rescue TypeError, NoMethodError
           false
+        ensure
+          $VERBOSE = save_verbose
         end
     end
   end

data/lib/.rbnext/2.6/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 array&.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