ruby-next-core 0.10.2 → 0.11.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fb44065be7545114c59e01e16394f6c4840c7efa173349b5907e6d07fa8b7694
-  data.tar.gz: bd8cb4e19884dfeb6059dc28d845bfb11061092ed888a2021ccf9575cdc72325
+  metadata.gz: 5408955fbe7d23afdc9d534e433c4c094b0a3ea46a47606a6caab7b6a4c446eb
+  data.tar.gz: 8b1edd6c3dbdc0322a4f3efa3eff5b4f278b2fd78bf8c9e995f1587b62278b0f
 SHA512:
-  metadata.gz: 521691a6abd8006d34ee48059d55b0aa43cbbe9c1d431a9d99b63f17bfec73e4e2e850dfac38e18f629131ccf5eae9899294c0741bd81bddbecd8d494aef2115
-  data.tar.gz: f12c6e59416eaec1f2e900691bff08235dda1bfdfb98d6cfe186f0ba90b2d0d2d8e1c2cc169f7abafbc0c785e65ceb6aba60cd3255dd2c4575c1c9352da7e94e
+  metadata.gz: 9f3483fb111153c9d9d14e4169302f4613a3428655b71ca83e77a5f7a6d906fc151712facec5f1c95742d77920db16bfa533fb5c34e01b8f3451f720a6fa442b
+  data.tar.gz: '09febbb7523724d5b23ba11814387dffe043d7574496923ed1731ba6664d2c9af2a02cba6568846ce6be96bdcb8e4a4eb341029c7d3099d0e02b64e9056d4744'

data/CHANGELOG.md

@@ -2,6 +2,42 @@
 
 ## master
 
+## 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][])
+
+You can try it: `x = 1; y = 2; foo(x:, y:) # => foo(x: x, y: y)`.
+
+- **Rewrite mode is used by default in transpiler**. ([@palkan][])
+
+- Move 3.0 features to stable features. ([@palkan][])
+
+- Refactor `a => x` and `a in x` to comply with Ruby 3.0. ([@palkan][])
+
+## 0.10.5 (2020-10-13)
+
+- Fix Unparser 0.5.0 compatibility. ([@palkan][])
+
+## 0.10.4 (2020-10-09)
+
+- Restrict Unparser dependency. ([@palkan][])
+
+Unparser 0.5.0 is currently not supported.
+
+## 0.10.3 (2020-09-28)
+
+- Update RuboCop integration to handle the latest Parser changes. ([@palkan][])
+
+Parser 2.7.1.5 unified endless and normal methods and rightward and leftward assignments, thus, making some cops report false negatives.
+
 ## 0.10.2 (2020-09-09)
 
 - Fix regression when `nextify` produces incorrect files for 2.7. ([@palkan][])

data/README.md

@@ -35,6 +35,7 @@ Read more about the motivation behind the Ruby Next in this post: [Ruby Next: Ma
 ## Examples
 
 - Ruby gems
+  - [action_policy](https://github.com/palkan/action_policy)
   - [anyway_config](https://github.com/palkan/anyway_config)
   - [graphql-fragment_cache](https://github.com/DmitryTsepelev/graphql-ruby-fragment_cache)
 - Rails applications
@@ -92,8 +93,7 @@ def greet(val) =
       '👽'
     end
 
-greet(hello: 'martian') => greeting
-puts greeting
+puts greet(hello: 'martian')
 "
 
 => 👽
@@ -178,17 +178,17 @@ In the AST mode, we parse the source code into AST, modifies this AST and **gene
 
 In the rewrite mode, we apply changes to the source code itself, thus, keeping the original formatting of the unaffected code (in a similar way to RuboCop's autocorrect feature).
 
-By default, we use the AST mode. That could likely change in the future when we collect enough feedback on the rewrite mode and fix potential bugs.
-
 The main benefit of the rewrite mode is that it preserves the original code line numbers and layout, which is especially useful in debugging.
 
+By default, we use the rewrite mode. If you found a bug with rewrite mode which is not reproducible in the AST mode, please, let us know.
+
 You can change the transpiler mode:
 
 - From code by setting `RubyNext::Language.mode = :ast` or `RubyNext::Language.mode = :rewrite`.
-- Via environmental variable `RUBY_NEXT_TRANSPILE_MODE=rewrite`.
+- Via environmental variable `RUBY_NEXT_TRANSPILE_MODE=ast`.
 - Via CLI option ([see below](#cli)).
 
-**NOTE:** For the time being, Unparser [doesn't support](https://github.com/mbj/unparser/pull/142) new Ruby 2.7 AST nodes, so we always use rewrite mode in Ruby 2.7+.
+**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
 
@@ -219,7 +219,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`). 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`). 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:
 
@@ -322,7 +322,7 @@ due to the way feature resolving works in Ruby (scanning the `$LOAD_PATH` and ha
 
 If you're using [runtime mode](#runtime-usage) a long with `setup_gem_load_path` (e.g., in tests), the transpiled files are ignored (i.e., we do not modify `$LOAD_PATH`).
 
-\* Ruby Next avoids storing duplicates; instead, only the code for the earlier version is created and is assumed to be used with other versions. For example, if the transpiled code is the same for Ruby 2.5 and Ruby 2.6, only the `.rbnext/2.7/path/to/file.rb` is kept. That's why multiple entries are added to the `$LOAD_PATH` (`.rbnext/2.6` and `.rbnext/2.7` in the specified order for Ruby 2.5 and only `.rbnext/2.7` for Ruby 2.6).
+\* Ruby Next avoids storing duplicates; instead, only the code for the earlier version is created and is assumed to be used with other versions. For example, if the transpiled code is the same for Ruby 2.5 and Ruby 2.6, only the `.rbnext/2.7/path/to/file.rb` is kept. That's why multiple entries are added to the `$LOAD_PATH` (`.rbnext/2.6`, `.rbnext/2.7`, and `.rbnext/3.0` in the specified order for Ruby 2.5, and `.rbnext/2.7` and `.rbnext/3.0` for Ruby 2.6).
 
 ### Transpiled files vs. VCS vs. installing from source
 
@@ -475,6 +475,8 @@ RUBY_NEXT_CORE_STRATEGY=backports ruby-next nextify lib/
 
 **NOTE:** For Ruby 2.2, safe navigation operator (`&.`) and squiggly heredocs (`<<~TXT`) support is provided.
 
+**IMPORTANT:** Unparser `~> 0.4.8` is required to run the transpiler on Ruby <2.4.
+
 ## Proposed and edge features
 
 Ruby Next aims to bring edge and proposed features to Ruby community before they (hopefully) reach an official Ruby release.
@@ -506,17 +508,13 @@ require "ruby-next/language/runtime"
 
 ### Supported edge features
 
-- "Endless" method definition (`def foo() = 42`) ([#16746](https://bugs.ruby-lang.org/issues/16746)).
-
-- Right-hand assignment (`13.divmod(5) => a,b`) ([#15921](https://bugs.ruby-lang.org/issues/15921)).
-
-- Find pattern (`[0, 1, 2] in [*, 1 => a, *c]`) ([#16828](https://bugs.ruby-lang.org/issues/16828)).
+No new features since 3.0 release.
 
 ### Supported proposed features
 
 - _Method reference_ operator (`.:`) ([#13581](https://bugs.ruby-lang.org/issues/13581)).
 
-- Shorthand Hash notation (`data = {x, y}`) ([#15236](https://bugs.ruby-lang.org/issues/15236)).
+- Shorthand Hash/kwarg notation (`data = {x, y}` or `foo(x:, y:)`) ([#15236](https://bugs.ruby-lang.org/issues/15236)).
 
 ## Contributing
 

data/bin/reparse

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+lib = File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+$VERBOSE = nil
+
+require "bundler/setup"
+
+require "ruby-next/language"
+
+contents =
+  if File.exist?(ARGV[0])
+    File.read(ARGV[0])
+  else
+    ARGV[0]
+  end
+
+ast = RubyNext::Language.parse(contents)
+puts Unparser.unparse(ast)

data/bin/transform

@@ -5,6 +5,13 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 require "bundler/setup"
 
+require "optparse"
+
+begin
+  require "pry-byebug"
+rescue LoadError
+end
+
 ENV["RUBY_NEXT_EDGE"] = "1"
 ENV["RUBY_NEXT_PROPOSED"] = "1"
 
@@ -13,16 +20,23 @@ require "ruby-next/language/rewriters/runtime"
 
 contents =
   if File.exist?(ARGV[0])
-    File.read(ARGV[0])
+    File.read(ARGV.shift)
   else
-    ARGV[0]
+    ARGV.shift
   end
 
-opts =
-  if ARGV[1] && ARGV[1] == "--current"
-    {rewriters: RubyNext::Language.current_rewriters}
-  else
-    {}
+transform_opts = {}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: transform filepath_or_code [options]"
+
+  opts.on("--current", "Use rewriters for the current Ruby version only") do
+    transform_opts[:rewriters] = RubyNext::Language.current_rewriters
+  end
+
+  opts.on("--rewrite", "User rewrite transpiling mode") do
+    RubyNext::Language.mode = :rewrite
   end
+end.parse!
 
-puts RubyNext::Language.transform(contents, **opts)
+puts RubyNext::Language.transform(contents, **transform_opts)

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

@@ -57,7 +57,7 @@ module RubyNext
 
           opts.on(
             "--transpile-mode=MODE",
-            "Transpiler mode (ast or rewrite). Default: ast"
+            "Transpiler mode (ast or rewrite). Default: rewrite"
           ) do |val|
             Language.mode = val.to_sym
           end
@@ -95,7 +95,7 @@ module RubyNext
           exit 0
         end
 
-        unless ((!lib_path.nil?) || nil) && lib_path.then(&File.method(:exist?))
+        unless ((!lib_path.nil? || nil) && lib_path.then(&File.method(:exist?)))
           $stdout.puts "Path not found: #{lib_path}"
           $stdout.puts optparser.help
           exit 2
@@ -148,6 +148,9 @@ module RubyNext
 
         # Then, generate the source code for the next version
         transpile path, contents, version: version
+      rescue SyntaxError, StandardError => e
+        warn "Failed to transpile #{path}: #{e.class} — #{e.message}"
+        exit 1
       end
 
       def save(contents, path, version)

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: ((!bind.nil? || nil) && bind.receiver) == TOPLEVEL_BINDING.receiver || ((!((!bind.nil? || nil) && bind.receiver).nil? || nil) && ((!bind.nil? || nil) && bind.receiver).is_a?(Module))
             )
             RubyNext.debug_source(new_source, "(#{caller_locations(1, 1).first})")
             super new_source, bind, *args
@@ -20,7 +20,7 @@ module RubyNext
     module InstanceEval # :nodoc:
       refine Object do
         def instance_eval(*args, &block)
-          return super(*args, &block) if block_given?
+          return super(*args, &block) if block
 
           source = args.shift
           new_source = ::RubyNext::Language::Runtime.transform(source, using: false)
@@ -33,7 +33,7 @@ module RubyNext
     module ClassEval
       refine Module do
         def module_eval(*args, &block)
-          return super(*args, &block) if block_given?
+          return super(*args, &block) if block
 
           source = args.shift
           new_source = ::RubyNext::Language::Runtime.transform(source, using: false)
@@ -42,7 +42,7 @@ module RubyNext
         end
 
         def class_eval(*args, &block)
-          return super(*args, &block) if block_given?
+          return super(*args, &block) if block
 
           source = args.shift
           new_source = ::RubyNext::Language::Runtime.transform(source, using: false)

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

@@ -60,7 +60,7 @@ module RubyNext
             eval_mid = Kernel.respond_to?(:eval_without_ruby_next) ? :eval_without_ruby_next : :eval
             Kernel.send eval_mid, self::SYNTAX_PROBE, nil, __FILE__, __LINE__
             false
-          rescue SyntaxError, NameError
+          rescue SyntaxError, StandardError
             true
           ensure
             $VERBOSE = save_verbose
@@ -93,25 +93,44 @@ module RubyNext
 
         private
 
+        # BFS with predicate block
+        def find_child(node)
+          queue = [node]
+
+          loop do
+            break if queue.empty?
+
+            child = queue.shift
+            next unless child.is_a?(::Parser::AST::Node)
+
+            return child if yield child
+
+            queue.push(*child.children)
+          end
+
+          nil
+        end
+
         def replace(range, ast)
-          ((!@source_rewriter.nil?) || nil) && @source_rewriter.replace(range, unparse(ast))
+          ((!@source_rewriter.nil? || nil) && @source_rewriter.replace(range, unparse(ast)))
         end
 
         def remove(range)
-          ((!@source_rewriter.nil?) || nil) && @source_rewriter.remove(range)
+          ((!@source_rewriter.nil? || nil) && @source_rewriter.remove(range))
         end
 
         def insert_after(range, ast)
-          ((!@source_rewriter.nil?) || nil) && @source_rewriter.insert_after(range, unparse(ast))
+          ((!@source_rewriter.nil? || nil) && @source_rewriter.insert_after(range, unparse(ast)))
         end
 
         def insert_before(range, ast)
-          ((!@source_rewriter.nil?) || nil) && @source_rewriter.insert_before(range, unparse(ast))
+          ((!@source_rewriter.nil? || nil) && @source_rewriter.insert_before(range, unparse(ast)))
         end
 
         def unparse(ast)
           return ast if ast.is_a?(String)
-          Unparser.unparse(ast)
+
+          Unparser.unparse(ast).chomp
         end
 
         attr_reader :context

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)
+          ((!((!current_index.nil? || nil) && current_index.children).nil? || nil) && ((!current_index.nil? || nil) && current_index.children).include?(node))
         end
       end
     end

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

@@ -13,12 +13,12 @@ module RubyNext
 
           # Useful to generate simple operation nodes
           # (e.g., 'a + b')
-          def -(val)
-            ::Parser::AST::Node.new(:send, [self, :-, val.to_ast_node])
+          def -(other)
+            ::Parser::AST::Node.new(:send, [self, :-, other.to_ast_node])
           end
 
-          def +(val)
-            ::Parser::AST::Node.new(:send, [self, :+, val.to_ast_node])
+          def +(other)
+            ::Parser::AST::Node.new(:send, [self, :+, other.to_ast_node])
           end
         end
 
@@ -218,9 +218,10 @@ module RubyNext
             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)
+          def hash_keys(node, keys)
+            keys = keys.map { |key| key.is_a?(::Parser::AST::Node) ? key.children.first : key }
+
+            predicate_clause(:"hash_keys_#{keys.join("_p_")}", node)
           end
         end
       end
@@ -244,7 +245,7 @@ module RubyNext
           @predicates = Predicates::CaseIn.new
 
           matchee_ast =
-            s(:lvasgn, MATCHEE, node.children[0])
+            s(:begin, s(:lvasgn, MATCHEE, node.children[0]))
 
           patterns = locals.with(
             matchee: MATCHEE,
@@ -266,14 +267,14 @@ module RubyNext
           )
         end
 
-        def on_in_match(node)
+        def on_match_pattern(node)
           context.track! self
 
           @deconstructed_keys = {}
           @predicates = Predicates::Noop.new
 
           matchee =
-            s(:lvasgn, MATCHEE, node.children[0])
+            s(:begin, s(:lvasgn, MATCHEE, node.children[0]))
 
           pattern =
             locals.with(
@@ -285,9 +286,10 @@ module RubyNext
                 :"#{node.children[1].type}_clause",
                 node.children[1]
               ).then do |node|
-                s(:or,
-                  node,
-                  no_matching_pattern)
+                s(:begin,
+                  s(:or,
+                    node,
+                    no_matching_pattern))
               end
             end
 
@@ -302,6 +304,8 @@ module RubyNext
           end
         end
 
+        alias on_in_match on_match_pattern
+
         private
 
         def rewrite_case_in!(node, matchee, new_node)
@@ -309,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 ((!clause.nil? || nil) && clause.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
@@ -340,7 +344,7 @@ module RubyNext
           clauses = []
 
           nodes.each do |clause|
-            if ((!clause.nil?) || nil) && clause.type == :in_pattern
+            if ((!clause.nil? || nil) && clause.type) == :in_pattern
               clauses << build_when_clause(clause)
             else
               else_clause = process(clause)
@@ -378,9 +382,10 @@ module RubyNext
           predicates.const(case_eq_clause(const, right), const).then do |node|
             next node if pattern.nil?
 
-            s(:and,
-              node,
-              send(:"#{pattern.type}_clause", pattern))
+            s(:begin,
+              s(:and,
+                node,
+                send(:"#{pattern.type}_clause", pattern)))
           end
         end
 
@@ -391,13 +396,14 @@ module RubyNext
               send :"#{child.type}_clause", child
             end
           end
-          s(:or, *children)
+          s(:begin, s(:or, *children))
         end
 
         def match_as_clause(node, right = s(:lvar, locals[:matchee]))
-          s(:and,
-            send(:"#{node.children[0].type}_clause", node.children[0], right),
-            match_var_clause(node.children[1], right))
+          s(:begin,
+            s(:and,
+              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]))
@@ -405,9 +411,10 @@ module RubyNext
 
           check_match_var_alternation! node.children[0]
 
-          s(:or,
-            s(:lvasgn, node.children[0], left),
-            s(:true))
+          s(:begin,
+            s(:or,
+              s(:begin, s(:lvasgn, node.children[0], left)),
+              s(:true)))
         end
 
         def pin_clause(node, right = s(:lvar, locals[:matchee]))
@@ -417,8 +424,8 @@ module RubyNext
 
         def case_eq_clause(node, right = s(:lvar, locals[:matchee]))
           predicates.terminate!
-          s(:send,
-            process(node), :===, right)
+          s(:begin, s(:send,
+            process(node), :===, right))
         end
 
         #=========== ARRAY PATTERN (START) ===============
@@ -429,10 +436,11 @@ module RubyNext
             # 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)),
+                s(:begin,
+                  s(:send,
+                    node.children.size.to_ast_node,
+                    :==,
+                    s(:send, s(:lvar, locals[:arr]), :size))),
                 node.children.size
               )
             end
@@ -448,9 +456,10 @@ module RubyNext
 
             right = s(:and, size_check, right) if size_check
 
-            s(:and,
-              dnode,
-              right)
+            s(:begin,
+              s(:and,
+                dnode,
+                right))
           end
         end
 
@@ -468,14 +477,17 @@ module RubyNext
           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"))))
+              s(:begin,
+                s(:and,
+                  s(:begin,
+                    s(:or,
+                      s(:begin, s(:lvasgn, locals[:arr], right)),
+                      s(:true))),
+                  s(:begin,
+                    s(:or,
+                      s(:send,
+                        s(:const, nil, :Array), :===, s(:lvar, locals[:arr])),
+                      raise_error(:TypeError, "#deconstruct must return Array"))))))
           )
         end
 
@@ -485,9 +497,10 @@ module RubyNext
           send("#{head.type}_array_element", head, index).then do |node|
             next node if tail.empty?
 
-            s(:and,
-              node,
-              array_element(index + 1, *tail))
+            s(:begin,
+              s(:and,
+                node,
+                array_element(index + 1, *tail)))
           end
         end
 
@@ -526,15 +539,17 @@ module RubyNext
 
           pattern = array_rest_element(*nodes, index).then do |needle|
             next needle unless head_match
-            s(:and,
-              needle,
-              head_match)
+            s(:begin,
+              s(:and,
+                needle,
+                head_match))
           end.then do |headed_needle|
             next headed_needle unless tail_match
 
-            s(:and,
-              headed_needle,
-              tail_match)
+            s(:begin,
+              s(:and,
+                headed_needle,
+                tail_match))
           end
 
           s(:block,
@@ -550,13 +565,14 @@ module RubyNext
             next block if match_vars.empty?
 
             # We need to declare match vars outside of `find` block
-            locals_declare = s(:masgn,
+            locals_declare = s(:begin, s(:masgn,
               s(:mlhs, *match_vars),
-              s(:nil))
+              s(:nil)))
 
-            s(:or,
-              locals_declare,
-              block)
+            s(:begin,
+              s(:or,
+                locals_declare,
+                block))
           end
         end
 
@@ -575,18 +591,20 @@ module RubyNext
 
           return rest if tail.empty?
 
-          s(:and,
-            rest,
-            array_rest_element(*tail, -(size - 1)))
+          s(:begin,
+            s(:and,
+              rest,
+              array_rest_element(*tail, -(size - 1))))
         end
 
         def array_rest_element(head, *tail, index)
           send("#{head.type}_array_element", head, index).then do |node|
             next node if tail.empty?
 
-            s(:and,
-              node,
-              array_rest_element(*tail, index + 1))
+            s(:begin,
+              s(:and,
+                node,
+                array_rest_element(*tail, index + 1)))
           end
         end
 
@@ -610,7 +628,7 @@ module RubyNext
           children = node.children.map do |child, i|
             send :"#{child.type}_array_element", child, index
           end
-          s(:or, *children)
+          s(:begin, s(:or, *children))
         end
 
         def match_var_array_element(node, index)
@@ -661,18 +679,20 @@ module RubyNext
               elsif specified_key_names.empty?
                 hash_element(*node.children)
               else
-                s(:and,
-                  having_hash_keys(specified_key_names),
-                  hash_element(*node.children))
+                s(:begin,
+                  s(:and,
+                    having_hash_keys(specified_key_names),
+                    hash_element(*node.children)))
               end
 
             predicates.pop
 
             next dnode if right.nil?
 
-            s(:and,
-              dnode,
-              right)
+            s(:begin,
+              s(:and,
+                dnode,
+                right))
           end
         end
 
@@ -715,7 +735,7 @@ module RubyNext
           # 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))
+              s(:begin, s(:lvasgn, locals[:hash], s(:send, s(:lvar, locals[:hash, :src]), :dup)))
             else
               s(:true)
             end
@@ -728,29 +748,33 @@ module RubyNext
           key_names = keys.children.map { |node| node.children.last }
           predicates.push locals[:hash]
 
-          s(:lvasgn, deconstruct_name,
+          s(:begin, s(:lvasgn, deconstruct_name,
             s(:send,
-              matchee, :deconstruct_keys, keys)).then do |dnode|
+              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"))))
+              s(:begin,
+                s(:and,
+                  s(:begin,
+                    s(:or,
+                      dnode,
+                      s(:true))),
+                  s(:begin,
+                    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,
-              dnode,
-              hash_dup)
+            s(:begin,
+              s(:and,
+                dnode,
+                hash_dup))
           end
         end
 
@@ -780,9 +804,10 @@ module RubyNext
 
             next node if right.nil?
 
-            s(:and,
-              node,
-              right)
+            s(:begin,
+              s(:and,
+                node,
+                right))
           end
         end
 
@@ -792,7 +817,7 @@ module RubyNext
         end
 
         def match_alt_hash_element(node, key)
-          element_node = s(:lvasgn, locals[:hash, :el], hash_value_at(key))
+          element_node = s(:begin, s(:lvasgn, locals[:hash, :el], hash_value_at(key)))
 
           children = locals.with(hash_element: locals[:hash, :el]) do
             node.children.map do |child, i|
@@ -800,11 +825,14 @@ module RubyNext
             end
           end
 
-          s(:and,
-            s(:or,
-              element_node,
-              s(:true)),
-            s(:or, *children))
+          s(:begin,
+            s(:and,
+              s(:begin,
+                s(:or,
+                  element_node,
+                  s(:true))),
+              s(:begin,
+                s(:or, *children))))
         end
 
         def match_as_hash_element(node, key)
@@ -858,13 +886,14 @@ module RubyNext
         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(nil) do |acc, key|
+            pnode = hash_has_key(key, hash)
+            next pnode unless acc
 
-          keys.reduce(node) do |res, key|
-            s(:and,
-              res,
-              predicates.hash_key(hash_has_key(key, hash), key))
+            s(:begin,
+              s(:and, acc, pnode))
+          end.then do |node|
+            predicates.hash_keys(node, keys)
           end
         end
 
@@ -873,9 +902,10 @@ module RubyNext
         def with_guard(node, guard)
           return node unless guard
 
-          s(:and,
-            node,
-            guard.children[0]).then do |expr|
+          s(:begin,
+            s(:and,
+              node,
+              guard.children[0])).then do |expr|
             next expr unless guard.type == :unless_guard
             s(:send, expr, :!)
           end
@@ -933,10 +963,10 @@ module RubyNext
           deconstructed_keys[key] = :"k#{deconstructed_keys.size}"
         end
 
-        # Unparser generates `do .. end`  blocks, we want to
+        # Unparser generates `do .. end` or `{ ... }` multiline blocks, we want to
         # have single-line blocks with `{ ... }`.
         def inline_blocks(source)
-          source.gsub(/do \|_, __i__\|\n\s*([^\n]+)\n\s*end/, '{ |_, __i__| \1 }')
+          source.gsub(/(?:do|{) \|_, __i__\|\n\s*([^\n]+)\n\s*(?:end|})/, '{ |_, __i__| \1 }')
         end
       end
     end