ruby-next-core 0.13.1 → 0.14.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 671c0ebc75d7ba834da83c55556fc9ed752fbbd6869788fc02435aef89f087b8
-  data.tar.gz: cb17c7ca0aafa112b50431f97170cdc16caba65fdbbb2bff6ebed039f1e2e489
+  metadata.gz: c8f084701e3c87e432518f6367d883b9524dbc002d77352793b912504a63e8d0
+  data.tar.gz: bc44011f4183dd2133f259f07dc7a40c4be5dbd4cf2f85e35efb525463011ace
 SHA512:
-  metadata.gz: 0642f3a3353f99d8ed5e76c4b530c748b7fc712c2ed04ba8e840a853087b3d94299ade88b83fd0ea472223bd5ee61f8c80618f818987ae541d4dc291eff8f0c2
-  data.tar.gz: 326aaccb2ec27ca7a28a802f755fcfc44748a825283d82d19055afe3a84d1b42eb9a48d41d5025b9b5be33230f6f88681e16b88537770270245b0435f457d49e
+  metadata.gz: eabbb2bc0ccfa86f033eabce8001d208638a3995c7f112c29ed0e5f3142597bc60d87112899e7d383b09739c7c4cbe2eff06d10c58df7577cf12f80d4cb19c4d
+  data.tar.gz: 000c76da160d8dba1231121b7e71b335da2d9775240bfc7a9fb2201ca55d6ac366f47f1c918a3c5ebb46abdcc90857b0c3a9d221455ed6eff68965f5b8f905e9

data/CHANGELOG.md

@@ -2,6 +2,46 @@
 
 ## master
 
+## 0.14.1 (2022-01-21)
+
+- Fix nested find patterns transpiling. ([@palkan][])
+
+## 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][])
+
+Postpone upgrade 'till v0.14 due to breaking shorthand hash changes.
+
+## 0.13.2 (2021-11-28)
+
+- Parser upgrade.
+
 ## 0.13.1 (2021-09-27)
 
 - Fix checking for realpath during $LOAD_PATH setup. ([@palkan][])

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}

@@ -243,6 +243,7 @@ module RubyNext
 
           @deconstructed_keys = {}
           @predicates = Predicates::CaseIn.new
+          @lvars = []
 
           matchee_ast =
             s(:begin, s(:lvasgn, MATCHEE, node.children[0]))
@@ -272,6 +273,7 @@ module RubyNext
 
           @deconstructed_keys = {}
           @predicates = Predicates::Noop.new
+          @lvars = []
 
           matchee =
             s(:begin, s(:lvasgn, MATCHEE, node.children[0]))
@@ -282,10 +284,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,
@@ -306,6 +310,41 @@ module RubyNext
 
         alias on_in_match on_match_pattern
 
+        def on_match_pattern_p(node)
+          context.track! self
+
+          @deconstructed_keys = {}
+          @predicates = Predicates::Noop.new
+          @lvars = []
+
+          matchee =
+            s(:begin, s(:lvasgn, MATCHEE, node.children[0]))
+
+          pattern =
+            locals.with(
+              matchee: MATCHEE,
+              arr: MATCHEE_ARR,
+              hash: MATCHEE_HASH
+            ) do
+              with_declared_locals do
+                send(
+                  :"#{node.children[1].type}_clause",
+                  node.children[1]
+                )
+              end
+            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)
@@ -363,13 +402,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)
@@ -407,13 +448,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)
 
           s(:begin,
             s(:or,
-              s(:begin, s(:lvasgn, node.children[0], left)),
+              s(:begin, build_var_assignment(var, left)),
               s(:true)))
         end
 
@@ -508,11 +550,10 @@ module RubyNext
         def array_find(head, *nodes, tail)
           index = s(:lvar, :__i__)
 
-          match_vars = []
-
           head_match =
             unless head.children.empty?
-              match_vars << s(:lvasgn, 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]),
@@ -524,16 +565,19 @@ module RubyNext
 
           tail_match =
             unless tail.children.empty?
-              match_vars << s(:lvasgn, 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 << s(:lvasgn, 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 << s(:lvasgn, 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
 
@@ -561,19 +605,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)
@@ -616,6 +648,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
@@ -796,6 +836,15 @@ 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 hash_element(head, *tail)
           send("#{head.type}_hash_element", head).then do |node|
             next node if tail.empty?
@@ -861,6 +910,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
@@ -911,6 +964,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,
@@ -945,13 +1016,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})"
@@ -968,6 +1043,18 @@ 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)
+          unless var.is_a?(::Parser::AST::Node)
+            lvars << var
+            return s(:lvasgn, *[var, value].compact)
+          end
+
+          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