ruby-next-core 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3c192e6090c23fb8d462dae6403a3e952f661bd0972f49eaaaba064cb2b07084
-  data.tar.gz: c72d83029a820636ce4809e727ad385a5d85bffafee94db2a4764f40eccb36f4
+  metadata.gz: '0456426952d07bcec1db2c70d256177bd8d1503c8edc7e667e2af62bf5f03ae3'
+  data.tar.gz: 4528e483af6cd8cdbf7b613454a0051abd5aaad4ec6cd02c727690d64fbfd848
 SHA512:
-  metadata.gz: 26eb5a69b3993cde39121bd19d710d5850f9dc722a807776bdf969b3fc0b52625de05f4f583e10b97fd137bc5c7a108c1c7b4582b8f541d109282c85ed244dc4
-  data.tar.gz: eed1785c806afd65b681f4b22c98658f0e2b43bc20d534ffc1382c476e600b2715d048e1e5409f65c43f92f9913531c1858b6a842348dd172526e1a2391f7865
+  metadata.gz: a25d4e8c619b0644f4bcb0f411d0f0c86d1aa7c343ab0e55b42c4d8adad10b2c5c7072ee13f019c9da29223774f6c34c353f58b64f32caf91e60040ec1b029a2
+  data.tar.gz: 02e6e9bdc4379b2542fe6802160f2946ac9d151878bea3f51bcd27da749f7e0bb2cf2891aa0ddf88f5a8221185d8ab9e1bdab4e639de6d69c2a44409e734626c

data/CHANGELOG.md

@@ -2,6 +2,17 @@
 
 ## master
 
+## 0.4.0 (2020-03-09)
+
+- Optimize pattern matching transpiled code. ([@palkan][])
+
+For array patterns, transpiled code is ~1.5-2x faster than native.
+For hash patterns it's about the same.
+
+- Pattern matching is 100% compatible with RubySpec. ([@palkan][])
+
+- Add `Symbol#start_with?/end_with?`. ([@palkan][])
+
 ## 0.3.0 (2020-02-14) 💕
 
 - Add `Time#floor` and `Time#ceil`. ([@palkan][])
@@ -48,7 +59,7 @@ You can still use this feature by enabling it explicitly (see Readme).
 - Support in modifier. ([@palkan][])
 
 ```ruby
-{a:1, b: 2} in {a:, **}
+{a: 1, b: 2} in {a:, **}
 p a #=> 1
 ```
 

data/README.md

@@ -3,9 +3,10 @@
 
 # Ruby Next
 
-> Make all Rubies quack like edge Ruby!
+<img align="right" height="184"
+     title="Ruby Next logo" src="./assets/images/logo.svg">
 
-Ruby Next is a collection of **polyfills** and a **transpiler** for supporting the latest and upcoming Ruby features (APIs and syntax) in older versions and alternative implementations. For example, you can use pattern matching and `Kernel#then` in Ruby 2.5 or [mruby][].
+Ruby Next is a **transpiler** and a collection of **polyfills** for supporting the latest and upcoming Ruby features (APIs and syntax) in older versions and alternative implementations. For example, you can use pattern matching and `Kernel#then` in Ruby 2.5 or [mruby][].
 
 Who might be interested in Ruby Next?
 
@@ -14,9 +15,10 @@ Who might be interested in Ruby Next?
 - **Users of non-MRI implementations** such as [mruby][], [JRuby][], [TruffleRuby][], [Opal][], [RubyMotion][], [Artichoke][], [Prism][].
 
 Ruby Next also aims to help the community to assess new, _experimental_, MRI features by making it easier to play with them.
-That's why Ruby Next implements the `trunk` features as fast as possible.
+That's why Ruby Next implements the `master` features as fast as possible.
 
-_⚡️ The project is in a **beta** phase. That means that the main functionality has been implemented (see [the list][features]) and APIs shouldn't change a lot in the nearest future. On the other hand, the number of users/projects is not enough to say we're "production-ready". So, can't wait to hear your feedback 🙂_
+<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>
 
 ## Links
 
@@ -92,7 +94,9 @@ gem "ruby-next"
 
 # gemspec
 spec.add_dependency "ruby-next"
+```
 
+```sh
 # or install globally
 gem install ruby-next
 ```
@@ -164,7 +168,7 @@ The behaviour depends on whether you transpile a single file or a directory:
 
 ```sh
 $ ruby-next nextify my_ruby.rb -o my_ruby_next.rb -V
-RubyNext core strategy: refine
+Ruby Next core strategy: refine
 Generated: my_ruby_next.rb
 ```
 
@@ -298,7 +302,7 @@ Then, add to your Gemfile:
 
 ```ruby
 source "https://rubygems.pkg.github.com/ruby-next" do
-  gem "parser", "2.7.0.100"
+  gem "parser", "~> 2.7.0.100", "< 2.7.1"
 end
 
 gem "ruby-next"
@@ -311,7 +315,7 @@ gem "ruby-next"
 You can install `ruby-next` globally by running the following commands:
 
 ```sh
-gem install parser -v "2.7.0.100" --source "https://USERNAME:ACCESS_TOKEN@rubygems.pkg.github.com/ruby-next"
+gem install parser -v "~> 2.7.0.100" -v "< 2.7.1" --source "https://USERNAME:ACCESS_TOKEN@rubygems.pkg.github.com/ruby-next"
 gem install ruby-next
 ```
 

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

@@ -144,7 +144,7 @@ module RubyNext
 
       def generation_meta
         <<~MSG
-          # Generated by RubyNext v#{RubyNext::VERSION} using the following command:
+          # Generated by Ruby Next v#{RubyNext::VERSION} using the following command:
           #
           #   #{original_command}
           #

data/lib/ruby-next/core.rb

@@ -152,6 +152,9 @@ require_relative "core/hash/merge"
 
 require_relative "core/string/split"
 
+require_relative "core/symbol/start_with"
+require_relative "core/symbol/end_with"
+
 require_relative "core/unboundmethod/bind_call"
 
 require_relative "core/time/floor"

data/lib/ruby-next/core/struct/deconstruct_keys.rb

@@ -8,8 +8,6 @@ RubyNext::Core.patch Struct, method: :deconstruct_keys, version: "2.7" do
 
       return to_h unless keys
 
-      return {} if size < keys.size
-
       keys.each_with_object({}) do |k, acc|
         # if k is Symbol and not a member of a Struct return {}
         next if (Symbol === k || String === k) && !members.include?(k.to_sym)

data/lib/ruby-next/core/symbol/end_with.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RubyNext::Core.patch Symbol, method: :end_with?, version: "2.7" do
+  <<~RUBY
+    def end_with?(*prefixes)
+      to_s.end_with?(*prefixes)
+    end
+  RUBY
+end

data/lib/ruby-next/core/symbol/start_with.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+RubyNext::Core.patch Symbol, method: :start_with?, version: "2.7" do
+  <<~RUBY
+    def start_with?(*prefixes)
+      to_s.start_with?(*prefixes)
+    end
+  RUBY
+end

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

@@ -31,6 +31,190 @@ module RubyNext
         end
       end)
 
+      # We can memoize structural predicates to avoid double calculation.
+      #
+      # For example, consider the following case and the corresponding predicate chains:
+      #
+      #    case val
+      #    in [:ok, 200] #=> [:respond_to_deconstruct, :deconstruct_type, :arr_size_is_2]
+      #    in [:created, 201] #=> [:respond_to_deconstruct, :deconstruct_type, :arr_size_is_2]
+      #    in [401 | 403] #=> [:respond_to_deconstruct, :deconstruct_type, :arr_size_is_1]
+      #    end
+      #
+      # We can minimize the number of predicate calls by storing the intermediate values (prefixed with `p_`) and using them
+      # in the subsequent calls:
+      #
+      #    case val
+      #    in [:ok, 200] #=> [:respond_to_deconstruct, :deconstruct_type, :arr_size_is_2]
+      #    in [:created, 201] #=> [:p_deconstructed, :p_arr_size_2]
+      #    in [401 | 403] #=> [:p_deconstructed, :arr_size_is_1]
+      #    end
+      #
+      # This way we mimic a naive decision tree algorithim.
+      module Predicates
+        class Processor < ::Parser::TreeRewriter
+          attr_reader :predicates
+
+          def initialize(predicates)
+            @predicates = predicates
+            super()
+          end
+
+          def on_lvasgn(node)
+            lvar, val = *node.children
+            if predicates.store[lvar] == false
+              process(val)
+            else
+              node
+            end
+          end
+
+          def on_and(node)
+            left, right = *node.children
+
+            if truthy(left)
+              process(right)
+            elsif truthy(right)
+              process(left)
+            else
+              node.updated(
+                :and,
+                [
+                  process(left),
+                  process(right)
+                ]
+              )
+            end
+          end
+
+          private
+
+          def truthy(node)
+            return false unless node.is_a?(::Parser::AST::Node)
+            return true if node.type == :true
+            return false if node.children.empty?
+
+            node.children.all? { |child| truthy(child) }
+          end
+        end
+
+        class Base
+          attr_reader :store, :predicates_by_path, :count, :terminated, :current_path
+          alias terminated? terminated
+
+          def initialize
+            # total number of predicates
+            @count = 0
+            # cache of all predicates by path
+            @predicates_by_path = {}
+            # all predicates and their dirty state
+            @store = {}
+
+            @current_path = []
+          end
+
+          def reset!
+            @current_path = []
+            @terminated = false
+          end
+
+          def push(path)
+            current_path << path
+          end
+
+          def pop
+            current_path.pop
+          end
+
+          def terminate!
+            @terminated = true
+          end
+
+          def predicate_clause(name, node)
+            if pred?(name)
+              read_pred(name)
+            else
+              write_pred(name, node)
+            end
+          end
+
+          def pred?(name)
+            predicates_by_path.key?(current_path + [name])
+          end
+
+          def read_pred(name)
+            lvar = predicates_by_path.fetch(current_path + [name])
+            # mark as used
+            store[lvar] = true
+            s(:lvar, lvar)
+          end
+
+          def write_pred(name, node)
+            return node if terminated?
+            @count += 1
+            lvar = :"__p_#{count}__"
+            predicates_by_path[current_path + [name]] = lvar
+            store[lvar] = false
+
+            s(:lvasgn,
+              lvar,
+              node)
+          end
+
+          def process(ast)
+            Processor.new(self).process(ast)
+          end
+
+          private
+
+          def s(type, *children)
+            ::Parser::AST::Node.new(type, children)
+          end
+        end
+
+        # rubocop:disable Style/MethodMissingSuper
+        # rubocop:disable Style/MissingRespondToMissing
+        class Noop < Base
+          # Return node itself, no memoization
+          def method_missing(mid, node, *)
+            node
+          end
+        end
+        # rubocop:enable Style/MethodMissingSuper
+        # rubocop:enable Style/MissingRespondToMissing
+
+        class CaseIn < Base
+          def const(node, const)
+            node
+          end
+
+          def respond_to_deconstruct(node)
+            predicate_clause(:respond_to_deconstruct, node)
+          end
+
+          def array_size(node, size)
+            predicate_clause(:"array_size_#{size}", node)
+          end
+
+          def array_deconstructed(node)
+            predicate_clause(:array_deconstructed, node)
+          end
+
+          def hash_deconstructed(node, keys)
+            predicate_clause(:"hash_deconstructed_#{keys.join("_p_")}", node)
+          end
+
+          def respond_to_deconstruct_keys(node)
+            predicate_clause(:respond_to_deconstruct_keys, node)
+          end
+
+          def hash_key(node, key)
+            key = key.children.first if key.is_a?(::Parser::AST::Node)
+            predicate_clause(:"hash_key_#{key}", node)
+          end
+        end
+      end
+
       class PatternMatching < Base
         SYNTAX_PROBE = "case 0; in 0; true; else; 1; end"
         MIN_SUPPORTED_VERSION = Gem::Version.new("2.7.0")
@@ -39,15 +223,19 @@ module RubyNext
         MATCHEE_ARR = :__m_arr__
         MATCHEE_HASH = :__m_hash__
 
+        ALTERNATION_MARKER = :__alt__
+        CURRENT_HASH_KEY = :__chk__
+
         def on_case_match(node)
           context.track! self
 
-          @deconstructed = []
+          @deconstructed_keys = {}
+          @predicates = Predicates::CaseIn.new
 
           matchee_ast =
             s(:lvasgn, MATCHEE, node.children[0])
 
-          ifs_ast = locals.with(
+          patterns = locals.with(
             matchee: MATCHEE,
             arr: MATCHEE_ARR,
             hash: MATCHEE_HASH
@@ -55,10 +243,13 @@ module RubyNext
             build_if_clause(node.children[1], node.children[2..-1])
           end
 
+          # remove unused predicate assignments and truthy expressions
+          patterns = predicates.process(patterns)
+
           node.updated(
             :begin,
             [
-              matchee_ast, ifs_ast
+              matchee_ast, patterns
             ]
           )
         end
@@ -66,6 +257,9 @@ module RubyNext
         def on_in_match(node)
           context.track! self
 
+          @deconstructed_keys = {}
+          @predicates = Predicates::Noop.new
+
           matchee =
             s(:lvasgn, MATCHEE, node.children[0])
 
@@ -98,11 +292,15 @@ module RubyNext
 
         def build_if_clause(node, rest)
           if node&.type == :in_pattern
+            predicates.reset!
             build_in_pattern(node, rest)
           else
             raise "Unexpected else in the middle of case ... in" if rest && rest.size > 0
             # else clause must be present
-            node || no_matching_pattern
+            (process(node) || no_matching_pattern).then do |else_node|
+              next else_node unless else_node.type == :empty_else
+              s(:empty)
+            end
           end
         end
 
@@ -115,7 +313,7 @@ module RubyNext
               ),
               clause.children[1] # guard
             ),
-            clause.children[2] || s(:nil) # expression
+            process(clause.children[2] || s(:nil)) # expression
           ].then do |children|
             if rest && rest.size > 0
               children << build_if_clause(rest.first, rest[1..-1])
@@ -125,10 +323,10 @@ module RubyNext
           end
         end
 
-        def const_pattern_clause(node)
+        def const_pattern_clause(node, right = s(:lvar, locals[:matchee]))
           const, pattern = *node.children
 
-          case_eq_clause(const).then do |node|
+          predicates.const(case_eq_clause(const, right), const).then do |node|
             next node if pattern.nil?
 
             s(:and,
@@ -138,37 +336,58 @@ module RubyNext
         end
 
         def match_alt_clause(node)
-          children = node.children.map do |child|
-            send :"#{child.type}_clause", child
+          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
+            end
           end
           s(:or, *children)
         end
 
         def match_as_clause(node, right = s(:lvar, locals[:matchee]))
           s(:and,
-            case_eq_clause(node.children[0]),
+            send(:"#{node.children[0].type}_clause", node.children[0], right),
             match_var_clause(node.children[1], right))
         end
 
         def match_var_clause(node, left = s(:lvar, locals[:matchee]))
+          return s(:true) if node.children[0] == :_
+
+          check_match_var_alternation! node.children[0]
+
           s(:or,
             s(:lvasgn, node.children[0], left),
-            s(:true)) # rubocop:disable Lint/BooleanSymbol
+            s(:true))
         end
 
-        def pin_clause(node)
-          case_eq_clause node.children[0]
+        def pin_clause(node, right = s(:lvar, locals[:matchee]))
+          predicates.terminate!
+          case_eq_clause node.children[0], right
         end
 
         def case_eq_clause(node, right = s(:lvar, locals[:matchee]))
+          predicates.terminate!
           s(:send,
-            node, :===, right)
+            process(node), :===, right)
         end
 
         #=========== ARRAY PATTERN (START) ===============
 
         def array_pattern_clause(node, matchee = s(:lvar, locals[:matchee]))
           deconstruct_node(matchee).then do |dnode|
+            size_check = nil
+            # if there is no rest or tail, match the size first
+            unless node.type == :array_pattern_with_tail || node.children.any? { |n| n.type == :match_rest }
+              size_check = predicates.array_size(
+                s(:send,
+                  node.children.size.to_ast_node,
+                  :==,
+                  s(:send, s(:lvar, locals[:arr]), :size)),
+                node.children.size
+              )
+            end
+
             right =
               if node.children.empty?
                 case_eq_clause(s(:array), s(:lvar, locals[:arr]))
@@ -176,49 +395,36 @@ module RubyNext
                 array_element(0, *node.children)
               end
 
-            # already deconsrtructed
-            next right if dnode.nil?
-
-            # if there is no rest or tail, match the size first
-            unless node.type == :array_pattern_with_tail || node.children.any? { |n| n.type == :match_rest }
-              right =
-                s(:and,
-                  s(:send,
-                    node.children.size.to_ast_node,
-                    :==,
-                    s(:send, s(:lvar, locals[:arr]), :size)),
-                  right)
-            end
+            right = s(:and, size_check, right) if size_check
 
             s(:and,
               dnode,
               right)
-          end.then do |right|
-            s(:and,
-              respond_to_check(matchee, :deconstruct),
-              right)
           end
         end
 
         alias array_pattern_with_tail_clause array_pattern_clause
 
         def deconstruct_node(matchee)
-          # only deconstruct once per case
-          return if deconstructed&.include?(locals[:arr])
-
           context.use_ruby_next!
 
+          # we do not memoize respond_to_check for arrays, 'cause
+          # we can memoize is together with #deconstruct result
+          respond_check = respond_to_check(matchee, :deconstruct)
           right = s(:send, matchee, :deconstruct)
 
-          deconstructed << locals[:arr] if deconstructed
-
-          s(:and,
-            s(:or,
-              s(:lvasgn, locals[:arr], right),
-              s(:true)), # rubocop:disable Lint/BooleanSymbol
-            s(:or,
-              case_eq_clause(s(:const, nil, :Array), s(:lvar, locals[:arr])),
-              raise_error(:TypeError, "#deconstruct must return Array")))
+          predicates.array_deconstructed(
+            s(:and,
+              respond_check,
+              s(:and,
+                s(:or,
+                  s(:lvasgn, locals[:arr], right),
+                  s(:true)),
+                s(:or,
+                  s(:send,
+                    s(:const, nil, :Array), :===, s(:lvar, locals[:arr])),
+                  raise_error(:TypeError, "#deconstruct must return Array"))))
+          )
         end
 
         def array_element(index, head, *tail)
@@ -237,6 +443,7 @@ module RubyNext
           child = node.children[0]
           rest = arr_rest_items(index, tail.size).then do |r|
             next r unless child
+
             match_var_clause(
               child,
               r
@@ -263,14 +470,16 @@ module RubyNext
         def array_pattern_array_element(node, index)
           element = arr_item_at(index)
           locals.with(arr: locals[:arr, index]) do
-            array_pattern_clause(node, element)
+            predicates.push :"i#{index}"
+            array_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
-            hash_pattern_clause(node, element)
+            predicates.push :"i#{index}"
+            hash_pattern_clause(node, element).tap { predicates.pop }
           end
         end
 
@@ -318,29 +527,42 @@ module RubyNext
           # (we use #dup and #delete when "reading" values when **rest is present
           # to assign the rest of the hash copy to it)
           @hash_match_rest = node.children.any? { |child| child.type == :match_rest || child.type == :match_nil_pattern }
-          keys = hash_pattern_keys(node.children)
+          keys = hash_pattern_destruction_keys(node.children)
+
+          specified_key_names = hash_pattern_keys(node.children)
 
           deconstruct_keys_node(keys, matchee).then do |dnode|
             right =
               if node.children.empty?
                 case_eq_clause(s(:hash), s(:lvar, locals[:hash]))
-              else
+              elsif specified_key_names.empty?
                 hash_element(*node.children)
+              else
+                s(:and,
+                  having_hash_keys(specified_key_names),
+                  hash_element(*node.children))
               end
 
+            predicates.pop
+
             next dnode if right.nil?
 
             s(:and,
               dnode,
               right)
-          end.then do |right|
-            s(:and,
-              respond_to_check(matchee, :deconstruct_keys),
-              right)
           end
         end
 
         def hash_pattern_keys(children)
+          children.filter_map do |child|
+            # Skip ** without var
+            next if child.type == :match_rest || child.type == :match_nil_pattern
+
+            send("#{child.type}_hash_key", child)
+          end
+        end
+
+        def hash_pattern_destruction_keys(children)
           return s(:nil) if children.empty?
 
           children.filter_map do |child|
@@ -357,51 +579,73 @@ module RubyNext
         end
 
         def match_var_hash_key(node)
+          check_match_var_alternation! node.children[0]
+
           s(:sym, node.children[0])
         end
 
         def deconstruct_keys_node(keys, matchee = s(:lvar, locals[:matchee]))
-          # Deconstruct once and use a copy of the hash for each pattern if we need **rest.
+          # Use original hash returned by #deconstruct_keys if not **rest matching,
+          # 'cause it remains immutable
+          deconstruct_name = @hash_match_rest ? locals[:hash, :src] : locals[:hash]
+
+          # Duplicate the source hash when matching **rest, 'cause we mutate it
           hash_dup =
             if @hash_match_rest
               s(:lvasgn, locals[:hash], s(:send, s(:lvar, locals[:hash, :src]), :dup))
             else
-              s(:lvasgn, locals[:hash], s(:lvar, locals[:hash, :src]))
+              s(:true)
             end
 
-          # Create a copy of the original hash if already deconstructed
-          # FIXME: need better algorithm to handle different key sets
-          # return hash_dup if deconstructed&.include?(locals[:hash])
-
           context.use_ruby_next!
 
-          deconstructed << locals[:hash] if deconstructed
+          respond_to_checked = predicates.pred?(:respond_to_deconstruct_keys)
+          respond_check = predicates.respond_to_deconstruct_keys(respond_to_check(matchee, :deconstruct_keys))
 
-          right = s(:send,
-            matchee, :deconstruct_keys, keys)
+          key_names = keys.children.map { |node| node.children.last }
+          predicates.push locals[:hash]
+
+          s(:lvasgn, deconstruct_name,
+            s(:send,
+              matchee, :deconstruct_keys, keys)).then do |dnode|
+            next dnode if respond_to_checked
+
+            s(:and,
+              respond_check,
+              s(:and,
+                s(:or,
+                  dnode,
+                  s(:true)),
+                s(:or,
+                  s(:send,
+                    s(:const, nil, :Hash), :===, s(:lvar, deconstruct_name)),
+                  raise_error(:TypeError, "#deconstruct_keys must return Hash"))))
+          end.then do |dnode|
+            predicates.hash_deconstructed(dnode, key_names)
+          end.then do |dnode|
+            next dnode unless @hash_match_rest
 
-          s(:and,
-            s(:or,
-              s(:lvasgn, locals[:hash, :src], right),
-              s(:true)), # rubocop:disable Lint/BooleanSymbol
             s(:and,
-              s(:or,
-                case_eq_clause(s(:const, nil, :Hash), s(:lvar, locals[:hash, :src])),
-                raise_error(:TypeError, "#deconstruct_keys must return Hash")),
-              hash_dup))
+              dnode,
+              hash_dup)
+          end
         end
 
         def hash_pattern_hash_element(node, key)
           element = hash_value_at(key)
-          locals.with(hash: locals[:hash, deconstructed.size]) do
-            hash_pattern_clause(node, element)
+          key_index = deconstructed_key(key)
+          locals.with(hash: locals[:hash, key_index]) do
+            predicates.push :"k#{key_index}"
+            hash_pattern_clause(node, element).tap { predicates.pop }
           end
         end
 
         def array_pattern_hash_element(node, key)
           element = hash_value_at(key)
-          locals.with(arr: locals[:hash, deconstructed.size]) do
-            array_pattern_clause(node, element)
+          key_index = deconstructed_key(key)
+          locals.with(arr: locals[:hash, key_index]) do
+            predicates.push :"k#{key_index}"
+            array_pattern_clause(node, element).tap { predicates.pop }
           end
         end
 
@@ -436,16 +680,17 @@ module RubyNext
           s(:and,
             s(:or,
               element_node,
-              s(:true)), # rubocop:disable Lint/BooleanSymbol
+              s(:true)),
             s(:or, *children))
         end
 
+        def match_as_hash_element(node, key)
+          match_as_clause(node, hash_value_at(key))
+        end
+
         def match_var_hash_element(node, key = nil)
           key ||= node.children[0]
-          # We need to check whether key is present first
-          s(:and,
-            hash_has_key(key),
-            match_var_clause(node, hash_value_at(key)))
+          match_var_clause(node, hash_value_at(key))
         end
 
         def match_nil_pattern_hash_element(node, _key = nil)
@@ -489,6 +734,17 @@ module RubyNext
             key.to_ast_node)
         end
 
+        def having_hash_keys(keys, hash = s(:lvar, locals[:hash]))
+          key = keys.shift
+          node = predicates.hash_key(hash_has_key(key, hash), key)
+
+          keys.reduce(node) do |res, key|
+            s(:and,
+              res,
+              predicates.hash_key(hash_has_key(key, hash), key))
+          end
+        end
+
         #=========== HASH PATTERN (END) ===============
 
         def with_guard(node, guard)
@@ -516,6 +772,7 @@ module RubyNext
             msg.to_ast_node)
         end
 
+        # Add respond_to? check
         def respond_to_check(node, mid)
           s(:send, node, :respond_to?, mid.to_ast_node)
         end
@@ -526,7 +783,7 @@ module RubyNext
         end
 
         def method_missing(mid, *args, &block)
-          return case_eq_clause(args.first) if mid.match?(/_clause$/)
+          return case_eq_clause(*args) if mid.match?(/_clause$/)
           return case_eq_array_element(*args) if mid.match?(/_array_element$/)
           return case_eq_hash_element(*args) if mid.match?(/_hash_element$/)
           super
@@ -534,7 +791,23 @@ module RubyNext
 
         private
 
-        attr_reader :deconstructed
+        attr_reader :deconstructed_keys, :predicates
+
+        # 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)
+
+          return if name.start_with?("_")
+
+          raise ::SyntaxError, "illegal variable in alternative pattern (#{name})"
+        end
+
+        def deconstructed_key(key)
+          return deconstructed_keys[key] if deconstructed_keys.key?(key)
+
+          deconstructed_keys[key] = :"k#{deconstructed_keys.size}"
+        end
       end
     end
   end

data/lib/ruby-next/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyNext
-  VERSION = "0.3.0"
+  VERSION = "0.4.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-next-core
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-15 00:00:00.000000000 Z
+date: 2020-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -76,6 +76,8 @@ files:
 - lib/ruby-next/core/string/split.rb
 - lib/ruby-next/core/struct/deconstruct.rb
 - lib/ruby-next/core/struct/deconstruct_keys.rb
+- lib/ruby-next/core/symbol/end_with.rb
+- lib/ruby-next/core/symbol/start_with.rb
 - lib/ruby-next/core/time/ceil.rb
 - lib/ruby-next/core/time/floor.rb
 - lib/ruby-next/core/unboundmethod/bind_call.rb