ruby-next-core 0.11.0 → 0.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 37dbd285f7d0d450d8458a2dc5c01e7b8c5f7744e54ea05d133ea7444dc9704c
-  data.tar.gz: 7a881b5d76d032ce4ee5a94515542bff75a3a5b899b8412d828d9c4a27728eda
+  metadata.gz: 671c0ebc75d7ba834da83c55556fc9ed752fbbd6869788fc02435aef89f087b8
+  data.tar.gz: cb17c7ca0aafa112b50431f97170cdc16caba65fdbbb2bff6ebed039f1e2e489
 SHA512:
-  metadata.gz: '0971fe638bfbd8c1ac3e5aa5485457fd9e9e70cfbb6f6430222d18ae13ce1820e97f3e28f93393d8c4ecc5578df0113d229b0179f5f07a2e1e19ae94087112ff'
-  data.tar.gz: aefa941c90244ae1e7c68eb7bae6f79c2fb936495e28158f8eb18a8b90dc8eb7dcbf35a50d133b8b1653a0bbb118469c989ed97cb6e7039d383c6264aca2f6bd
+  metadata.gz: 0642f3a3353f99d8ed5e76c4b530c748b7fc712c2ed04ba8e840a853087b3d94299ade88b83fd0ea472223bd5ee61f8c80618f818987ae541d4dc291eff8f0c2
+  data.tar.gz: 326aaccb2ec27ca7a28a802f755fcfc44748a825283d82d19055afe3a84d1b42eb9a48d41d5025b9b5be33230f6f88681e16b88537770270245b0435f457d49e

data/CHANGELOG.md

@@ -2,6 +2,38 @@
 
 ## master
 
+## 0.13.1 (2021-09-27)
+
+- Fix checking for realpath during $LOAD_PATH setup. ([@palkan][])
+
+## 0.13.0 (2021-09-27)
+
+- Added `Enumerable#tally` with the resulting hash. ([@skryukov][])
+
+- Added `Array#intersect?`. ([@skryukov][])
+
+## 0.12.0 (2021-01-12)
+
+- Added required keyword arguments rewriter. ([@palkan][])
+
+Required kwargs were introduced in 2.1. Now we make them possible in 2.0.
+
+- Added numeric literals rewriter. ([@palkan][])
+
+Now it's possible to generate Ruby 2.0 compatible code from `2i + 1/3r`.
+
+- Fixed several safe navigation (`&.`) bugs. ([@palkan][])
+
+See [#68](https://github.com/ruby-next/ruby-next/issues/68) and [#69](https://github.com/ruby-next/ruby-next/issues/69).
+
+## 0.11.1 (2020-12-28)
+
+- Use separate _namespace_ for proposed features to avoid conflicts with new Ruby version. ([@palkan][])
+
+Previously, we used the upcoming Ruby version number for proposed features (e.g., `3.0.0`), which broke
+the load path setup, since transpiled files were not loaded anymore.
+Now that's fixed by using a _virtual_ version number for proposals (`1995.next.0`).
+
 ## 0.11.0 (2020-12-24) 🎄
 
 - Extended proposed shorthand Hash syntax to support kwargs as well. ([@palkan][])
@@ -259,3 +291,4 @@ p a #=> 1
 [@palkan]: https://github.com/palkan
 [backports]: https://github.com/marcandre/backports
 [@sl4vr]: https://github.com/sl4vr
+[@skryukov]: https://github.com/skryukov

data/README.md

@@ -21,8 +21,20 @@ That's why Ruby Next implements the `master` features as fast as possible.
 
 Read more about the motivation behind the Ruby Next in this post: [Ruby Next: Make all Rubies quack alike](https://evilmartians.com/chronicles/ruby-next-make-all-rubies-quack-alike).
 
-<a href="https://evilmartians.com/?utm_source=ruby-next">
-<img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54"></a>
+<table style="border:none;">
+<tr>
+<td>
+     <a href="https://evilmartians.com/?utm_source=ruby-next">
+          <img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54">
+     </a>
+</td>
+<td>
+     <a href="http://www.digitalfukuoka.jp/topics/169">
+          <img src="http://www.digitalfukuoka.jp/javascripts/kcfinder/upload/images/excellence.jpg" width="200">
+     </a>
+</td>
+</tr>
+</table>
 
 ## Posts
 
@@ -445,6 +457,8 @@ AllCops:
 
 We currently provide support for Ruby 2.2, 2.3 and 2.4.
 
+**NOTE:** By "support" here we mean using `ruby-next` CLI and runtime transpiling. Transpiled code may run on Ruby 2.0+.
+
 Ruby Next itself relies on 2.5 features and contains polyfills only for version 2.5+ (and that won't change).
 Thus, to make it work with <2.5 we need to backport some APIs ourselves.
 
@@ -508,7 +522,7 @@ require "ruby-next/language/runtime"
 
 ### Supported edge features
 
-No new features since 3.0 release.
+`Array#intersect?` ([#15198](https://bugs.ruby-lang.org/issues/15198))
 
 ### Supported proposed features
 

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

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require "set"
+
+require "ruby-next/config"
+require "ruby-next/utils"
+
+module RubyNext
+  module Core
+    # Patch contains the extension implementation
+    # and meta information (e.g., Ruby version).
+    class Patch
+      attr_reader :refineables, :name, :mod, :method_name, :version, :body, :singleton, :core_ext, :supported, :native, :location
+
+      # Create a new patch for module/class (mod)
+      # with the specified uniq name
+      #
+      # `core_ext` defines the strategy for core extensions:
+      #    - :patch — extend class directly
+      #    - :prepend — extend class by prepending a module (e.g., when needs `super`)
+      def initialize(mod = nil, method: ::Kernel.raise(::ArgumentError, "missing keyword: method"), version: ::Kernel.raise(::ArgumentError, "missing keyword: version"), name: nil, supported: nil, native: nil, location: nil, refineable: mod, core_ext: :patch, singleton: nil)
+        @mod = mod
+        @method_name = method
+        @version = version
+        if method_name && mod
+          @supported = supported.nil? ? mod.method_defined?(method_name) : supported
+          # define whether running Ruby has a native implementation for this method
+          # for that, we check the source_location (which is nil for C defined methods)
+          @native = native.nil? ? (supported? && native_location?(mod.instance_method(method_name).source_location)) : native
+        end
+        @singleton = singleton
+        @refineables = Array(refineable)
+        @body = yield
+        @core_ext = core_ext
+        @location = location || build_location(caller_locations(1, 5))
+        @name = name || build_module_name
+      end
+
+      def prepend?
+        core_ext == :prepend
+      end
+
+      def core_ext?
+        !mod.nil?
+      end
+
+      alias supported? supported
+      alias native? native
+      alias singleton? singleton
+
+      def to_module
+        Module.new.tap do |ext|
+          ext.module_eval(body, *location)
+
+          RubyNext::Core.const_set(name, ext)
+        end
+      end
+
+      private
+
+      def build_module_name
+        mod_name = singleton? ? singleton.name : mod.name
+        camelized_method_name = method_name.to_s.split("_").map(&:capitalize).join
+
+        "#{mod_name}#{camelized_method_name}".gsub(/\W/, "")
+      end
+
+      def build_location(trace_locations)
+        # The caller_locations behaviour depends on implementaion,
+        # e.g. in JRuby https://github.com/jruby/jruby/issues/6055
+        while trace_locations.first.label != "patch"
+          trace_locations.shift
+        end
+
+        trace_location = trace_locations[1]
+
+        [trace_location.absolute_path, trace_location.lineno + 2]
+      end
+
+      def native_location?(location)
+        location.nil? || location.first.match?(/(<internal:|resource:\/truffleruby\/core)/)
+      end
+    end
+
+    # Registry for patches
+    class Patches
+      attr_reader :extensions, :refined
+
+      def initialize
+        @names = Set.new
+        @extensions = Hash.new { |h, k| h[k] = [] }
+        @refined = Hash.new { |h, k| h[k] = [] }
+      end
+
+      # Register new patch
+      def <<(patch)
+        raise ArgumentError, "Patch already registered: #{patch.name}" if @names.include?(patch.name)
+        @names << patch.name
+        @extensions[patch.mod] << patch if patch.core_ext?
+        patch.refineables.each { |r| @refined[r] << patch } unless patch.native?
+      end
+    end
+
+    class << self
+      STRATEGIES = %i[refine core_ext backports].freeze
+
+      attr_reader :strategy
+
+      def strategy=(val)
+        raise ArgumentError, "Unknown strategy: #{val}. Available: #{STRATEGIES.join(",")}" unless STRATEGIES.include?(val)
+        @strategy = val
+      end
+
+      def refine?
+        strategy == :refine
+      end
+
+      def core_ext?
+        strategy == :core_ext || strategy == :backports
+      end
+
+      def backports?
+        strategy == :backports
+      end
+
+      def patch(*__rest__, &__block__)
+        patches << Patch.new(*__rest__, &__block__)
+      end
+
+      # Inject `using RubyNext` at the top of the source code
+      def inject!(contents)
+        if contents.frozen?
+          contents = contents.sub(/^(\s*[^#\s].*)/, 'using RubyNext;\1')
+        else
+          contents.sub!(/^(\s*[^#\s].*)/, 'using RubyNext;\1')
+        end
+        contents
+      end
+
+      def patches
+        @patches ||= Patches.new
+      end
+    end
+
+    # Use refinements by default
+    self.strategy = ENV.fetch("RUBY_NEXT_CORE_STRATEGY", "refine").to_sym
+  end
+end
+
+require "backports/2.5" if RubyNext::Core.backports?
+
+require "ruby-next/core/kernel/then"
+
+require "ruby-next/core/proc/compose"
+
+require "ruby-next/core/enumerable/tally"
+require "ruby-next/core/enumerable/filter"
+require "ruby-next/core/enumerable/filter_map"
+
+require "ruby-next/core/enumerator/produce"
+
+require "ruby-next/core/array/difference_union_intersection"
+
+require "ruby-next/core/hash/merge"
+
+require "ruby-next/core/string/split"
+
+require "ruby-next/core/symbol/start_with"
+require "ruby-next/core/symbol/end_with"
+
+require "ruby-next/core/unboundmethod/bind_call"
+
+require "ruby-next/core/time/floor"
+require "ruby-next/core/time/ceil"
+
+# Core extensions required for pattern matching
+# Required for pattern matching with refinements
+unless defined?(NoMatchingPatternError)
+  class NoMatchingPatternError < StandardError
+  end
+end
+
+require "ruby-next/core/constants/no_matching_pattern_error"
+require "ruby-next/core/constants/frozen_error"
+require "ruby-next/core/array/deconstruct"
+require "ruby-next/core/hash/deconstruct_keys"
+require "ruby-next/core/struct/deconstruct"
+require "ruby-next/core/struct/deconstruct_keys"
+
+require "ruby-next/core/hash/except"
+
+require "ruby-next/core/array/intersect"
+
+# Generate refinements
+RubyNext.module_eval do
+  RubyNext::Core.patches.refined.each do |mod, patches|
+    # Only refine modules when supported
+    next unless mod.is_a?(Class) || RubyNext::Utils.refine_modules?
+
+    refine mod do
+      patches.each do |patch|
+        module_eval(patch.body, *patch.location)
+      end
+    end
+  end
+end

data/lib/.rbnext/2.1/ruby-next/language.rb

@@ -0,0 +1,227 @@
+# frozen_string_literal: true
+
+gem "ruby-next-parser", ">= 2.8.0.3"
+gem "unparser", ">= 0.4.7"
+
+require "set"
+
+require "ruby-next"
+
+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
+    using RubyNext
+
+    require "ruby-next/language/parser"
+    require "ruby-next/language/unparser"
+
+    RewriterNotFoundError = Class.new(StandardError)
+
+    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
+
+      attr_accessor :strategy
+
+      MODES = %i[rewrite ast].freeze
+
+      attr_reader :mode
+
+      def mode=(val)
+        raise ArgumentError, "Unknown mode: #{val}. Available: #{MODES.join(",")}" unless MODES.include?(val)
+        @mode = val
+      end
+
+      def rewrite?
+        mode == :rewrite?
+      end
+
+      def ast?
+        mode == :ast
+      end
+
+      def runtime!
+        require "ruby-next/language/rewriters/runtime"
+
+        @runtime = true
+      end
+
+      def runtime?
+        @runtime
+      end
+
+      def transform(source, rewriters: self.rewriters, using: RubyNext::Core.refine?, context: TransformContext.new)
+        retried = 0
+        new_source = nil
+        begin
+          new_source =
+            if mode == :rewrite
+              rewrite(source, rewriters: rewriters, using: using, context: context)
+            else
+              regenerate(source, rewriters: rewriters, using: using, context: context)
+            end
+        rescue Unparser::UnknownNodeError => err
+          RubyNext.warn "Ruby Next fallbacks to \"rewrite\" transpiling mode since the version of Unparser you use doesn't support some syntax yet: #{err.message}.\n" \
+            "Try upgrading the Unparser or set transpiling mode to \"rewrite\" in case you use some edge or experimental syntax."
+          self.mode = :rewrite
+          retried += 1
+          retry unless retried > 1
+          raise
+        end
+
+        return new_source unless RubyNext::Core.refine?
+        return new_source unless using && context.use_ruby_next?
+
+        Core.inject! new_source.dup
+      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
+
+      # This method guarantees that rewriters will be returned in order they defined in Language module
+      def select_rewriters(*names)
+        rewriters_delta = names - rewriters.map { |rewriter| rewriter::NAME }
+        if rewriters_delta.any?
+          raise RewriterNotFoundError, "Rewriters not found: #{rewriters_delta.join(",")}"
+        end
+
+        rewriters.select { |rewriter| names.include?(rewriter::NAME) }
+      end
+
+      private
+
+      def regenerate(source, rewriters: ::Kernel.raise(::ArgumentError, "missing keyword: rewriters"), using: ::Kernel.raise(::ArgumentError, "missing keyword: using"), context: ::Kernel.raise(::ArgumentError, "missing keyword: context"))
+        parse_with_comments(source).then do |(ast, comments)|
+          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, comments)
+          end
+        end
+      end
+
+      def rewrite(source, rewriters: ::Kernel.raise(::ArgumentError, "missing keyword: rewriters"), using: ::Kernel.raise(::ArgumentError, "missing keyword: using"), context: ::Kernel.raise(::ArgumentError, "missing keyword: context"))
+        rewriters.inject(source) do |src, rewriter|
+          buffer = Parser::Source::Buffer.new("<dynamic>")
+          buffer.source = src
+
+          rewriter.new(context).rewrite(buffer, parse(src))
+        end.then do |new_source|
+          next source unless context.dirty?
+
+          new_source
+        end
+      end
+
+      attr_writer :watch_dirs
+    end
+
+    self.rewriters = []
+    self.watch_dirs = %w[app lib spec test].map { |path| File.join(Dir.pwd, path) }
+    self.mode = ENV.fetch("RUBY_NEXT_TRANSPILE_MODE", "rewrite").to_sym
+
+    require "ruby-next/language/rewriters/base"
+
+    require "ruby-next/language/rewriters/squiggly_heredoc"
+    rewriters << Rewriters::SquigglyHeredoc
+
+    require "ruby-next/language/rewriters/safe_navigation"
+    rewriters << Rewriters::SafeNavigation
+
+    require "ruby-next/language/rewriters/numeric_literals"
+    rewriters << Rewriters::NumericLiterals
+
+    require "ruby-next/language/rewriters/required_kwargs"
+    rewriters << Rewriters::RequiredKwargs
+
+    require "ruby-next/language/rewriters/args_forward"
+    rewriters << Rewriters::ArgsForward
+
+    # Must be added after general args forward rewriter to become
+    # no-op in Ruby <2.7
+    require "ruby-next/language/rewriters/args_forward_leading"
+    rewriters << Rewriters::ArgsForwardLeading
+
+    require "ruby-next/language/rewriters/numbered_params"
+    rewriters << Rewriters::NumberedParams
+
+    require "ruby-next/language/rewriters/pattern_matching"
+    rewriters << Rewriters::PatternMatching
+
+    # Must be added after general pattern matching rewriter to become
+    # no-op in Ruby <2.7
+    require "ruby-next/language/rewriters/find_pattern"
+    rewriters << Rewriters::FindPattern
+
+    require "ruby-next/language/rewriters/in_pattern"
+    rewriters << Rewriters::InPattern
+
+    # Put endless range in the end, 'cause Parser fails to parse it in
+    # pattern matching
+    require "ruby-next/language/rewriters/endless_range"
+    rewriters << Rewriters::EndlessRange
+
+    require "ruby-next/language/rewriters/endless_method"
+    RubyNext::Language.rewriters << RubyNext::Language::Rewriters::EndlessMethod
+
+    if ENV["RUBY_NEXT_EDGE"] == "1"
+      require "ruby-next/language/edge"
+    end
+
+    if ENV["RUBY_NEXT_PROPOSED"] == "1"
+      require "ruby-next/language/proposed"
+    end
+  end
+end

data/lib/.rbnext/2.3/ruby-next/commands/nextify.rb

@@ -95,7 +95,7 @@ module RubyNext
           exit 0
         end
 
-        unless ((!lib_path.nil? || nil) && lib_path.then(&File.method(:exist?)))
+        unless ((((__safe_lvar__ = lib_path) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.then(&File.method(:exist?)))
           $stdout.puts "Path not found: #{lib_path}"
           $stdout.puts optparser.help
           exit 2

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

@@ -8,7 +8,7 @@ module RubyNext
           def eval(source, bind = nil, *args)
             new_source = ::RubyNext::Language::Runtime.transform(
               source,
-              using: ((!bind.nil? || nil) && bind.receiver) == TOPLEVEL_BINDING.receiver || ((!((!bind.nil? || nil) && bind.receiver).nil? || nil) && ((!bind.nil? || nil) && bind.receiver).is_a?(Module))
+              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

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

@@ -112,19 +112,19 @@ module RubyNext
         end
 
         def replace(range, ast)
-          ((!@source_rewriter.nil? || nil) && @source_rewriter.replace(range, unparse(ast)))
+          ((((__safe_lvar__ = @source_rewriter) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.replace(range, unparse(ast)))
         end
 
         def remove(range)
-          ((!@source_rewriter.nil? || nil) && @source_rewriter.remove(range))
+          ((((__safe_lvar__ = @source_rewriter) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.remove(range))
         end
 
         def insert_after(range, ast)
-          ((!@source_rewriter.nil? || nil) && @source_rewriter.insert_after(range, unparse(ast)))
+          ((((__safe_lvar__ = @source_rewriter) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.insert_after(range, unparse(ast)))
         end
 
         def insert_before(range, ast)
-          ((!@source_rewriter.nil? || nil) && @source_rewriter.insert_before(range, unparse(ast)))
+          ((((__safe_lvar__ = @source_rewriter) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.insert_before(range, unparse(ast)))
         end
 
         def unparse(ast)

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

@@ -55,7 +55,7 @@ module RubyNext
         attr_reader :current_index
 
         def index_arg?(node)
-          ((!((!current_index.nil? || nil) && current_index.children).nil? || nil) && ((!current_index.nil? || nil) && current_index.children).include?(node))
+          ((((__safe_lvar__ = ((((__safe_lvar__ = current_index) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.children)) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.include?(node))
         end
       end
     end

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

@@ -313,7 +313,7 @@ module RubyNext
           remove(node.children[0].loc.expression)
 
           node.children[1..-1].each.with_index do |clause, i|
-            if ((!clause.nil? || nil) && clause.type) == :in_pattern
+            if ((((__safe_lvar__ = clause) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.type) == :in_pattern
               # handle multiline clauses differently
               if clause.loc.last_line > clause.children[0].loc.last_line + 1
                 height = clause.loc.last_line - clause.children[0].loc.last_line
@@ -344,7 +344,7 @@ module RubyNext
           clauses = []
 
           nodes.each do |clause|
-            if ((!clause.nil? || nil) && clause.type) == :in_pattern
+            if ((((__safe_lvar__ = clause) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.type) == :in_pattern
               clauses << build_when_clause(clause)
             else
               else_clause = process(clause)
@@ -353,7 +353,7 @@ module RubyNext
 
           else_clause = (else_clause || no_matching_pattern).then do |node|
             next node unless node.type == :empty_else
-            s(:empty)
+            nil
           end
 
           clauses << else_clause

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

@@ -6,7 +6,7 @@ module RubyNext
 
     if $LOAD_PATH.respond_to?(:resolve_feature_path)
       def resolve_feature_path(feature)
-        ((!$LOAD_PATH.resolve_feature_path(feature).nil? || nil) && $LOAD_PATH.resolve_feature_path(feature).last)
+        ((((__safe_lvar__ = $LOAD_PATH.resolve_feature_path(feature)) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.last)
       rescue LoadError
       end
     else

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

@@ -181,6 +181,7 @@ unless defined?(NoMatchingPatternError)
 end
 
 require "ruby-next/core/constants/no_matching_pattern_error"
+require "ruby-next/core/constants/frozen_error"
 require "ruby-next/core/array/deconstruct"
 require "ruby-next/core/hash/deconstruct_keys"
 require "ruby-next/core/struct/deconstruct"
@@ -188,6 +189,8 @@ require "ruby-next/core/struct/deconstruct_keys"
 
 require "ruby-next/core/hash/except"
 
+require "ruby-next/core/array/intersect"
+
 # Generate refinements
 RubyNext.module_eval do
   RubyNext::Core.patches.refined.each do |mod, patches|

data/lib/ruby-next/config.rb

@@ -15,6 +15,9 @@ module RubyNext
 
   LATEST_VERSION = [3, 0].freeze
 
+  # A virtual version number used for proposed features
+  NEXT_VERSION = "1995.next.0"
+
   class << self
     # TruffleRuby claims it's 2.7.2 compatible but...
     if defined?(TruffleRuby) && ::RUBY_VERSION =~ /^2\.7/
@@ -28,9 +31,11 @@ module RubyNext
     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 if major >= LATEST_VERSION.first && minor >= LATEST_VERSION.last
+      return Gem::Version.new(NEXT_VERSION) if major >= LATEST_VERSION.first && minor >= LATEST_VERSION.last
 
       nxt =
         if LAST_MINOR_VERSIONS[major] == minor

data/lib/ruby-next/core/array/intersect.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RubyNext::Core.patch Array, method: :intersect?, version: "3.1" do
+  <<-RUBY
+def intersect?(other)
+  !(self & other).empty?
+end
+  RUBY
+end