ruby-next-core 0.13.3 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8c37d70af44462c4f2a42db64ca27a9b99fa08e9278d5e308dd3ba5fb67aa7b3
-  data.tar.gz: fb832052e7479e0c5719e57904b105f47721d1688e9ec47f4d58d7f75de9fffb
+  metadata.gz: 55cb050984d91ee15965b5629bd998d7300af1051e7ad721f1dfed77fc6df7c7
+  data.tar.gz: ac68a6f7da2b826b11a40be72948601f2d12ce8b1cd27ab9953977238c1e488d
 SHA512:
-  metadata.gz: dd6760a195e2ca5aa0b47295069526fbe67aa183e28dc36d6076aa3fc0d3b58411320d043f1c7f2a9c19803193b6b84ff4a640cfa0fe3e14d813032340fe0ad4
-  data.tar.gz: 6f2bf81c74312a1e1e3b68ac24df8ca2eb7ce679f8de9c8009c9550e880b0f8a0c18d7532f0570e003cd9511502af6607219f44e065be8d54d975a44e5dd12e5
+  metadata.gz: 7cd0de569637973ff61866733a6a3d59dac4e317bf5e522b23a88fc5af8941e4a072ae1dfbf26163a661c71911f7801545cad00134cd826d4913f684b03473e8
+  data.tar.gz: 2ebf8f0a42bd0771cfbc2f2240a3844436d3f108e5cec292ec2cd7e3bebef0a332088357a892cf3cd2b0c6835e9f39679cc472cd6a0ac4d120850194d8f2e783

data/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 ## master
 
+## 0.14.0 🎄
+
+- Add `Integer.try_convert`. ([@palkan][])
+
+- Add `Enumerable#compact`, `Enumerator::Lazy#compact`. ([@palkan][])
+
+- [Proposed] Add support for binding instance, class, global variables in pattern matching. ([@palkan][])
+
+This brings back rightward assignment: `42 => @v`.
+
+- Add `MatchData#match`. ([@palkan][])
+
+- Add support for command syntax in endless methods (`def foo() = puts "bar"`)
+
+- Add `Refinement#import_methods` support. ([@palkan][])
+
+This API only works in conjunction with transpiling, since it couldn't be backported purely as a method and requires passing an additional argument (Binding).
+
+You can find the details in [the PR](https://github.com/ruby-next/ruby-next/pull/85).
+
+- Added support for instance, class and global variables and expressions for pin operator. ([@palkan][])
+
+- Support omitting parentheses in one-line pattern matching. ([@palkan][])
+
+- Anonymous blocks `def b(&); c(&); end` ([@palkan][]).
+
 ## 0.13.3 (2021-12-08)
 
 - Revert 0.13.2 and freeze Parser version. ([@skryukov][])

data/README.md

@@ -73,6 +73,7 @@ _Please, submit a PR to add your project to the list!_
 - [RuboCop](#rubocop)
 - [Using with EOL Rubies](#using-with-eol-rubies)
 - [Proposed & edge features](#proposed-and-edge-features)
+- [Known limitations](#known-limitations)
 
 ## Overview
 
@@ -200,8 +201,6 @@ You can change the transpiler mode:
 - Via environmental variable `RUBY_NEXT_TRANSPILE_MODE=ast`.
 - Via CLI option ([see below](#cli)).
 
-**NOTE:** For the time being, Unparser doesn't support Ruby 3.0 AST nodes, so we always use rewrite mode in Ruby 3.0+.
-
 ## CLI
 
 Ruby Next ships with the command-line interface (`ruby-next`) which provides the following functionality:
@@ -231,7 +230,7 @@ Usage: ruby-next nextify DIRECTORY_OR_FILE [options]
 
 The behaviour depends on whether you transpile a single file or a directory:
 
-- When transpiling a directory, the `.rbnext` subfolder is created within the target folder with subfolders for each supported Ruby versions (e.g., `.rbnext/2.6`, `.rbnext/2.7`, `.rbnext/3.0`). If you want to create only a single version (the smallest), you can also pass `--single-version` flag. In that case, no version directory is created (i.e., transpiled files go into `.rbnext`).
+- When transpiling a directory, the `.rbnext` subfolder is created within the target folder with subfolders for each supported Ruby versions (e.g., `.rbnext/2.6`, `.rbnext/2.7`, `.rbnext/3.0`, etc.). If you want to create only a single version (the smallest), you can also pass `--single-version` flag. In that case, no version directory is created (i.e., transpiled files go into `.rbnext`).
 
 - When transpiling a file and providing the output path as a _file_ path, only a single version is created. For example:
 
@@ -283,6 +282,8 @@ $ ruby-next core_ext -l --name=filter --name=deconstruct
   - EnumeratorLazyFilterMap
   - HashDeconstructKeys
   - StructDeconstruct
+
+...
 ```
 
 ### CLI configuration file
@@ -522,13 +523,38 @@ require "ruby-next/language/runtime"
 
 ### Supported edge features
 
-`Array#intersect?` ([#15198](https://bugs.ruby-lang.org/issues/15198))
+It's too early, Ruby 3.1 has just been released. See its features in the [supported features list](./SUPPORTED_FEATURES.md).
 
 ### Supported proposed features
 
 - _Method reference_ operator (`.:`) ([#13581](https://bugs.ruby-lang.org/issues/13581)).
+- Binding non-local variables in pattern matching (`42 => @v`) ([#18408](https://bugs.ruby-lang.org/issues/18408)).
+
+## Known limitations
+
+Ruby Next aims to be _reasonably compatible_ with MRI. That means, some edge cases could be uncovered. Below is the list of known limitations.
+
+For gem authors, we recommend testing against all supported versions on CI to make sure you're not hit by edge cases.
+
+### Enumerable methods
+
+Using refinements (`using RubyNext`) for modules could lead to unexpected behaviour in case there is also a `prepend` for the same module in Ruby <2.7.
+To eliminate this, we also refine Array (when appropriate), but other enumerables could be affected.
+
+See [this issue](https://bugs.ruby-lang.org/issues/13446) for details.
+
+### `Refinement#import_methods`
+
+- Doesn't support importing methods generated with `eval`.
+- Doesn't support aliases (both `alias` and `alias_method`).
+- In JRuby, importing attribute accessors/readers/writers is not supported.
+- When using AST transpiling in runtime, likely fails to import methods from a transpiled files (due to the updated source location).
+
+See the [original PR](https://github.com/ruby-next/ruby-next/pull/85) for more details.
+
+### Other
 
-- Shorthand Hash/kwarg notation (`data = {x, y}` or `foo(x:, y:)`) ([#15236](https://bugs.ruby-lang.org/issues/15236)).
+See [Parser's known issues](https://github.com/whitequark/parser#known-issues).
 
 ## Contributing
 

data/bin/transform

@@ -34,9 +34,13 @@ OptionParser.new do |opts|
     transform_opts[:rewriters] = RubyNext::Language.current_rewriters
   end
 
-  opts.on("--rewrite", "User rewrite transpiling mode") do
+  opts.on("--rewrite", "Use rewrite transpiling mode") do
     RubyNext::Language.mode = :rewrite
   end
+
+  opts.on("--ast", "Use AST transpiling mode") do
+    RubyNext::Language.mode = :ast
+  end
 end.parse!
 
 puts RubyNext::Language.transform(contents, **transform_opts)

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

@@ -62,7 +62,7 @@ module RubyNext
         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/, "")
+        "#{mod_name}#{camelized_method_name}".gsub(/\W/, "") # rubocop:disable Performance/StringReplacement
       end
 
       def build_location(trace_locations)
@@ -173,6 +173,8 @@ require "ruby-next/core/unboundmethod/bind_call"
 require "ruby-next/core/time/floor"
 require "ruby-next/core/time/ceil"
 
+require "ruby-next/core/refinement/import"
+
 # Core extensions required for pattern matching
 # Required for pattern matching with refinements
 unless defined?(NoMatchingPatternError)
@@ -191,6 +193,10 @@ require "ruby-next/core/hash/except"
 
 require "ruby-next/core/array/intersect"
 
+require "ruby-next/core/matchdata/match"
+require "ruby-next/core/enumerable/compact"
+require "ruby-next/core/integer/try_convert"
+
 # Generate refinements
 RubyNext.module_eval do
   RubyNext::Core.patches.refined.each do |mod, patches|

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

@@ -174,54 +174,72 @@ module RubyNext
 
     require "ruby-next/language/rewriters/base"
 
-    require "ruby-next/language/rewriters/squiggly_heredoc"
+    require "ruby-next/language/rewriters/2.1/numeric_literals"
+    rewriters << Rewriters::NumericLiterals
+
+    require "ruby-next/language/rewriters/2.1/required_kwargs"
+    rewriters << Rewriters::RequiredKwargs
+
+    require "ruby-next/language/rewriters/2.3/squiggly_heredoc"
     rewriters << Rewriters::SquigglyHeredoc
 
-    require "ruby-next/language/rewriters/safe_navigation"
+    require "ruby-next/language/rewriters/2.3/safe_navigation"
     rewriters << Rewriters::SafeNavigation
 
-    require "ruby-next/language/rewriters/numeric_literals"
-    rewriters << Rewriters::NumericLiterals
+    require "ruby-next/language/rewriters/2.7/args_forward"
+    rewriters << Rewriters::ArgsForward
 
-    require "ruby-next/language/rewriters/required_kwargs"
-    rewriters << Rewriters::RequiredKwargs
+    require "ruby-next/language/rewriters/2.7/numbered_params"
+    rewriters << Rewriters::NumberedParams
 
-    require "ruby-next/language/rewriters/args_forward"
-    rewriters << Rewriters::ArgsForward
+    require "ruby-next/language/rewriters/2.7/pattern_matching"
+    rewriters << Rewriters::PatternMatching
 
     # Must be added after general args forward rewriter to become
     # no-op in Ruby <2.7
-    require "ruby-next/language/rewriters/args_forward_leading"
+    require "ruby-next/language/rewriters/3.0/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"
+    require "ruby-next/language/rewriters/3.0/find_pattern"
     rewriters << Rewriters::FindPattern
 
-    require "ruby-next/language/rewriters/in_pattern"
+    require "ruby-next/language/rewriters/3.0/in_pattern"
     rewriters << Rewriters::InPattern
 
+    require "ruby-next/language/rewriters/3.0/endless_method"
+    RubyNext::Language.rewriters << RubyNext::Language::Rewriters::EndlessMethod
+
+    require "ruby-next/language/rewriters/3.1/oneline_pattern_parensless"
+    rewriters << Rewriters::OnelinePatternParensless
+
+    require "ruby-next/language/rewriters/3.1/pin_vars_pattern"
+    rewriters << Rewriters::PinVarsPattern
+
+    require "ruby-next/language/rewriters/3.1/anonymous_block"
+    rewriters << Rewriters::AnonymousBlock
+
+    require "ruby-next/language/rewriters/3.1/refinement_import_methods"
+    rewriters << Rewriters::RefinementImportMethods
+
+    require "ruby-next/language/rewriters/3.1/endless_method_command"
+    rewriters << Rewriters::EndlessMethodCommand
+
+    require "ruby-next/language/rewriters/3.1/shorthand_hash"
+    rewriters << RubyNext::Language::Rewriters::ShorthandHash
+
     # Put endless range in the end, 'cause Parser fails to parse it in
     # pattern matching
-    require "ruby-next/language/rewriters/endless_range"
+    require "ruby-next/language/rewriters/2.6/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"
+      require "ruby-next/language/rewriters/edge"
     end
 
     if ENV["RUBY_NEXT_PROPOSED"] == "1"
-      require "ruby-next/language/proposed"
+      require "ruby-next/language/rewriters/proposed"
     end
   end
 end

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

@@ -48,11 +48,11 @@ module RubyNext
           end
 
           opts.on("--edge", "Enable edge (master) Ruby features") do |val|
-            require "ruby-next/language/edge"
+            require "ruby-next/language/rewriters/edge"
           end
 
           opts.on("--proposed", "Enable proposed/experimental Ruby features") do |val|
-            require "ruby-next/language/proposed"
+            require "ruby-next/language/rewriters/proposed"
           end
 
           opts.on(

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

@@ -37,6 +37,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
         end

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

@@ -306,6 +306,38 @@ module RubyNext
 
         alias on_in_match on_match_pattern
 
+        def on_match_pattern_p(node)
+          context.track! self
+
+          @deconstructed_keys = {}
+          @predicates = Predicates::Noop.new
+
+          matchee =
+            s(:begin, s(:lvasgn, MATCHEE, node.children[0]))
+
+          pattern =
+            locals.with(
+              matchee: MATCHEE,
+              arr: MATCHEE_ARR,
+              hash: MATCHEE_HASH
+            ) do
+              send(
+                :"#{node.children[1].type}_clause",
+                node.children[1]
+              )
+            end
+
+          node.updated(
+            :and,
+            [
+              matchee,
+              pattern
+            ]
+          ).tap do |new_node|
+            replace(node.loc.expression, inline_blocks(unparse(new_node)))
+          end
+        end
+
         private
 
         def rewrite_case_in!(node, matchee, new_node)
@@ -407,13 +439,14 @@ module RubyNext
         end
 
         def match_var_clause(node, left = s(:lvar, locals[:matchee]))
-          return s(:true) if node.children[0] == :_
+          var = node.children[0]
+          return s(:true) if var == :_
 
-          check_match_var_alternation! node.children[0]
+          check_match_var_alternation!(var) unless var.is_a?(::Parser::AST::Node)
 
           s(:begin,
             s(:or,
-              s(:begin, s(:lvasgn, node.children[0], left)),
+              s(:begin, build_var_assignment(var, left)),
               s(:true)))
         end
 
@@ -512,7 +545,7 @@ module RubyNext
 
           head_match =
             unless head.children.empty?
-              match_vars << s(:lvasgn, head.children[0].children[0])
+              match_vars << build_var_assignment(head.children[0].children[0])
 
               arr_take = s(:send,
                 s(:lvar, locals[:arr]),
@@ -524,16 +557,16 @@ module RubyNext
 
           tail_match =
             unless tail.children.empty?
-              match_vars << s(:lvasgn, tail.children[0].children[0])
+              match_vars << 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 << s(:lvasgn, node.children[0])
+              match_vars << build_var_assignment(node.children[0])
             elsif node.type == :match_as
-              match_vars << s(:lvasgn, node.children[1].children[0])
+              match_vars << build_var_assignment(node.children[1].children[0])
             end
           end
 
@@ -861,6 +894,10 @@ module RubyNext
           match_var_clause(child, s(:lvar, locals[:hash]))
         end
 
+        def pin_hash_element(node, index)
+          case_eq_hash_element node.children[0], index
+        end
+
         def case_eq_hash_element(node, key)
           case_eq_clause node, hash_value_at(key)
         end
@@ -968,6 +1005,15 @@ module RubyNext
         def inline_blocks(source)
           source.gsub(/(?:do|{) \|_, __i__\|\n\s*([^\n]+)\n\s*(?:end|})/, '{ |_, __i__| \1 }')
         end
+
+        # 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)
+
+          asign_type = :"#{var.type.to_s[0]}vasgn"
+
+          s(asign_type, *[var.children[0], value].compact)
+        end
       end
     end
   end

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

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RubyNext
+  module Language
+    module Rewriters
+      class AnonymousBlock < Base
+        NAME = "anonymous-block"
+        SYNTAX_PROBE = "obj = Object.new; def obj.foo(&) bar(&); end"
+        MIN_SUPPORTED_VERSION = Gem::Version.new("3.1.0")
+
+        BLOCK = :__block__
+
+        def on_args(node)
+          block = node.children.last
+
+          return super unless ((((__safe_lvar__ = block) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.type) == :blockarg
+          return super unless block.children.first.nil?
+
+          context.track! self
+
+          replace(block.loc.expression, "&#{BLOCK}")
+
+          node.updated(
+            :args,
+            [
+              *node.children.slice(0, node.children.index(block)),
+              s(:blockarg, BLOCK)
+            ]
+          )
+        end
+
+        def on_send(node)
+          block = extract_block_pass(node)
+          return super unless ((((__safe_lvar__ = block) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.children) == [nil]
+
+          process_block(node, block)
+        end
+
+        def on_super(node)
+          block = extract_block_pass(node)
+          return super unless ((((__safe_lvar__ = block) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.children) == [nil]
+
+          process_block(node, block)
+        end
+
+        private
+
+        def extract_block_pass(node)
+          node.children.find { |child| child.is_a?(::Parser::AST::Node) && child.type == :block_pass }
+        end
+
+        def process_block(node, block)
+          replace(block.loc.expression, "&#{BLOCK}")
+
+          process(
+            node.updated(
+              nil,
+              [
+                *node.children.take(node.children.index(block)),
+                s(:block_pass, s(:lvar, BLOCK))
+              ]
+            )
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -14,6 +14,18 @@ module RubyNext
 
       class Base < ::Parser::TreeRewriter
         class LocalsTracker
+          using(Module.new do
+            refine ::Parser::AST::Node do
+              def to_index
+                ((((__safe_lvar__ = children) || true) && (!__safe_lvar__.nil? || nil)) && __safe_lvar__.first) || type
+              end
+            end
+
+            refine ::Object do
+              alias to_index itself
+            end
+          end)
+
           attr_reader :stacks
 
           def initialize
@@ -28,7 +40,7 @@ module RubyNext
           def [](name, suffix = nil)
             fetch(name).then do |name|
               next name unless suffix
-              :"#{name}#{suffix}__"
+              :"#{name}#{suffix.to_index}__"
             end
           end
 

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

@@ -62,7 +62,7 @@ module RubyNext
         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/, "")
+        "#{mod_name}#{camelized_method_name}".gsub(/\W/, "") # rubocop:disable Performance/StringReplacement
       end
 
       def build_location(trace_locations)
@@ -173,6 +173,8 @@ require "ruby-next/core/unboundmethod/bind_call"
 require "ruby-next/core/time/floor"
 require "ruby-next/core/time/ceil"
 
+require "ruby-next/core/refinement/import"
+
 # Core extensions required for pattern matching
 # Required for pattern matching with refinements
 unless defined?(NoMatchingPatternError)
@@ -191,6 +193,10 @@ require "ruby-next/core/hash/except"
 
 require "ruby-next/core/array/intersect"
 
+require "ruby-next/core/matchdata/match"
+require "ruby-next/core/enumerable/compact"
+require "ruby-next/core/integer/try_convert"
+
 # Generate refinements
 RubyNext.module_eval do
   RubyNext::Core.patches.refined.each do |mod, patches|

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

@@ -48,11 +48,11 @@ module RubyNext
           end
 
           opts.on("--edge", "Enable edge (master) Ruby features") do |val|
-            require "ruby-next/language/edge"
+            require "ruby-next/language/rewriters/edge"
           end
 
           opts.on("--proposed", "Enable proposed/experimental Ruby features") do |val|
-            require "ruby-next/language/proposed"
+            require "ruby-next/language/rewriters/proposed"
           end
 
           opts.on(

data/lib/ruby-next/config.rb

@@ -10,10 +10,10 @@ module RubyNext
   # 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 => 0
+    3 => 1
   }.freeze
 
-  LATEST_VERSION = [3, 0].freeze
+  LATEST_VERSION = [3, 1].freeze
 
   # A virtual version number used for proposed features
   NEXT_VERSION = "1995.next.0"

data/lib/ruby-next/core/enumerable/compact.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+RubyNext::Core.patch Enumerable, method: :compact, version: "3.1" do
+  <<-RUBY
+def compact
+  reduce([]) do |acc, val|
+    acc << val unless val.nil?
+    acc
+  end
+end
+  RUBY
+end
+
+RubyNext::Core.patch Enumerator::Lazy, method: :compact, version: "3.1" do
+  <<-RUBY
+def compact
+  Enumerator::Lazy.new(self) do |yielder, value|
+    yielder << value unless value.nil?
+  end
+end
+  RUBY
+end

data/lib/ruby-next/core/integer/try_convert.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+RubyNext::Core.patch Integer.singleton_class, method: :try_convert, singleton: Integer, version: "3.1" do
+  <<-'RUBY'
+def try_convert(val)
+  return val if val.is_a?(Integer)
+
+  if val.respond_to?(:to_int)
+    val.to_int.tap do |res|
+      next if res.is_a?(Integer) || res.nil?
+      raise TypeError, "Can't convert #{res.class} to Integer"
+    end
+  end
+end
+  RUBY
+end

data/lib/ruby-next/core/matchdata/match.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RubyNext::Core.patch MatchData, method: :match, version: "3.1" do
+  <<-RUBY
+def match(index_or_name)
+  self[index_or_name]
+end
+  RUBY
+end

data/lib/ruby-next/core/refinement/import.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+# We cannot use refinements here, since Ruby 2.6- doesn't support them in refine modules.
+# So, we use a defined method instead (and transpile source code to use it).
+# NOTE: We have to transpile the source code anyway, since we need to pass a binding.
+RubyNext::Core.singleton_class.module_eval do
+  def import_methods(other, bind)
+    import = []
+
+    other.instance_methods(false).each do |mid|
+      # check for non-Ruby methods
+      meth = other.instance_method(mid)
+      location = meth.source_location
+
+      if location.nil? || location.first.match?(/(<internal:|resource:\/truffleruby\/core)/)
+        raise ArgumentError, "Can't import method: #{other}##{mid} from #{location}"
+      end
+
+      source_file, lineno = *location
+
+      raise ArgumentError, "Can't import dynamicly added methods: #{other}##{mid}" unless File.file?(source_file)
+
+      lines = File.open(source_file).readlines
+
+      buffer = []
+
+      lines[(lineno - 1)..-1].each do |line|
+        buffer << line + "\n"
+
+        begin
+          if defined?(::RubyNext::Language) && ::RubyNext::Language.runtime?
+            new_source = ::RubyNext::Language.transform(buffer.join, rewriters: RubyNext::Language.current_rewriters, using: false)
+            # Transformed successfully => valid method => evaluate transpiled code
+            import << [new_source, source_file, lineno]
+            buffer.clear
+            break
+          end
+
+          # Borrowed from https://github.com/banister/method_source/blob/81d039c966ffd95d26e12eb2e205c0eb8377f49d/lib/method_source/code_helpers.rb#L66
+          catch(:valid) do
+            eval("BEGIN{throw :valid}\nObject.new.instance_eval { #{buffer.join} }") # rubocop:disable all
+          end
+          break
+        rescue SyntaxError
+        end
+      end
+
+      import << [buffer.join, source_file, lineno] unless buffer.empty?
+    end
+
+    import.each do |(definition, file, lino)|
+      Kernel.eval definition, bind, file, lino
+    end
+
+    # Copy constants (they could be accessed from methods)
+    other.constants.each do |name|
+      Kernel.eval "#{name} = #{other}::#{name}", bind
+    end
+  end
+end