rubocop 0.67.2 → 0.68.0

data/lib/rubocop/cop/style/redundant_return.rb

@@ -90,6 +90,8 @@ module RuboCop
 
         # rubocop:disable Metrics/CyclomaticComplexity
         def check_branch(node)
+          return unless node
+
           case node.type
           when :return then check_return_node(node)
           when :case   then check_case_node(node)
@@ -111,25 +113,15 @@ module RuboCop
         end
 
         def check_case_node(node)
-          _cond, *when_nodes, else_node = *node
-          when_nodes.each { |when_node| check_when_node(when_node) }
-          check_branch(else_node) if else_node
-        end
-
-        def check_when_node(node)
-          return unless node
-
-          _cond, body = *node
-          check_branch(body) if body
+          node.when_branches.each { |when_node| check_branch(when_node.body) }
+          check_branch(node.else_branch)
         end
 
         def check_if_node(node)
           return if node.modifier_form? || node.ternary?
 
-          _cond, if_node, else_node = *node.node_parts
-
-          check_branch(if_node) if if_node
-          check_branch(else_node) if else_node
+          check_branch(node.if_branch)
+          check_branch(node.else_branch)
         end
 
         def check_rescue_node(node)

data/lib/rubocop/cop/style/redundant_sort_by.rb

@@ -35,7 +35,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          send, = *node
+          send = node.send_node
           ->(corrector) { corrector.replace(sort_by_range(send, node), 'sort') }
         end
 

data/lib/rubocop/cop/style/safe_navigation.rb

@@ -65,6 +65,8 @@ module RuboCop
 
         MSG = 'Use safe navigation (`&.`) instead of checking if an object ' \
               'exists before calling the method.'.freeze
+        LOGIC_JUMP_KEYWORDS = %i[break fail next raise
+                                 return throw yield].freeze
 
         minimum_target_ruby_version 2.3
 
@@ -149,6 +151,7 @@ module RuboCop
 
           checked_variable, matching_receiver, method =
             extract_common_parts(receiver, variable)
+          matching_receiver = nil if LOGIC_JUMP_KEYWORDS.include?(receiver.type)
           [checked_variable, matching_receiver, receiver, method]
         end
 

data/lib/rubocop/cop/style/struct_inheritance.rb

@@ -24,10 +24,9 @@ module RuboCop
               'Use a block to customize the struct.'.freeze
 
         def on_class(node)
-          _name, superclass, _body = *node
-          return unless struct_constructor?(superclass)
+          return unless struct_constructor?(node.parent_class)
 
-          add_offense(node, location: superclass.source_range)
+          add_offense(node, location: node.parent_class.source_range)
         end
 
         def_node_matcher :struct_constructor?, <<-PATTERN

data/lib/rubocop/cop/style/symbol_proc.rb

@@ -32,46 +32,38 @@ module RuboCop
         end
 
         def on_block(node)
-          symbol_proc?(node) do |send_or_super, block_args, method|
-            block_method_name = resolve_block_method_name(send_or_super)
-
+          symbol_proc?(node) do |dispatch_node, arguments_node, method_name|
             # TODO: Rails-specific handling that we should probably make
             # configurable - https://github.com/rubocop-hq/rubocop/issues/1485
             # we should ignore lambdas & procs
-            return if proc_node?(send_or_super)
-            return if %i[lambda proc].include?(block_method_name)
-            return if ignored_method?(block_method_name)
-            return if block_args.children.size == 1 &&
-                      block_args.source.include?(',')
+            return if proc_node?(dispatch_node)
+            return if %i[lambda proc].include?(dispatch_node.method_name)
+            return if ignored_method?(dispatch_node.method_name)
+            return if destructuring_block_argument?(arguments_node)
 
-            offense(node, method, block_method_name)
+            register_offense(node, method_name, dispatch_node.method_name)
           end
         end
 
+        def destructuring_block_argument?(argument_node)
+          argument_node.one? && argument_node.source.include?(',')
+        end
+
         def autocorrect(node)
           lambda do |corrector|
-            block_send_or_super, _block_args, block_body = *node
-            _receiver, method_name, _args = *block_body
-
-            if super?(block_send_or_super)
-              args = *block_send_or_super
+            if node.send_node.arguments?
+              autocorrect_with_args(corrector, node,
+                                    node.send_node.arguments,
+                                    node.body.method_name)
             else
-              _breceiver, _bmethod_name, *args = *block_send_or_super
+              autocorrect_without_args(corrector, node)
             end
-            autocorrect_method(corrector, node, args, method_name)
           end
         end
 
         private
 
-        def resolve_block_method_name(block_send_or_super)
-          return :super if super?(block_send_or_super)
-
-          _receiver, method_name, _args = *block_send_or_super
-          method_name
-        end
-
-        def offense(node, method_name, block_method_name)
+        def register_offense(node, method_name, block_method_name)
           block_start = node.loc.begin.begin_pos
           block_end = node.loc.end.end_pos
           range = range_between(block_start, block_end)
@@ -83,16 +75,9 @@ module RuboCop
                                       block_method: block_method_name))
         end
 
-        def autocorrect_method(corrector, node, args, method_name)
-          if args.empty?
-            autocorrect_no_args(corrector, node, method_name)
-          else
-            autocorrect_with_args(corrector, node, args, method_name)
-          end
-        end
-
-        def autocorrect_no_args(corrector, node, method_name)
-          corrector.replace(block_range_with_space(node), "(&:#{method_name})")
+        def autocorrect_without_args(corrector, node)
+          corrector.replace(block_range_with_space(node),
+                            "(&:#{node.body.method_name})")
         end
 
         def autocorrect_with_args(corrector, node, args, method_name)
@@ -111,8 +96,7 @@ module RuboCop
         end
 
         def begin_pos_for_replacement(node)
-          block_send_or_super, _block_args, _block_body = *node
-          expr = block_send_or_super.source_range
+          expr = node.send_node.source_range
 
           if (paren_pos = (expr.source =~ /\(\s*\)$/))
             expr.begin_pos + paren_pos
@@ -120,10 +104,6 @@ module RuboCop
             node.loc.begin.begin_pos
           end
         end
-
-        def super?(node)
-          SUPER_TYPES.include?(node.type)
-        end
       end
     end
   end

data/lib/rubocop/cop/style/unless_else.rb

@@ -32,8 +32,7 @@ module RuboCop
         end
 
         def autocorrect(node)
-          condition, = *node
-          body_range = range_between_condition_and_else(node, condition)
+          body_range = range_between_condition_and_else(node, node.condition)
           else_range = range_between_else_and_end(node)
 
           lambda do |corrector|

data/lib/rubocop/cop/style/yoda_condition.rb

@@ -98,7 +98,8 @@ module RuboCop
         end
 
         def valid_yoda?(node)
-          lhs, _operator, rhs = *node
+          lhs = node.receiver
+          rhs = node.first_argument
 
           return true if lhs.literal? && rhs.literal? ||
                          !lhs.literal? && !rhs.literal?
@@ -111,8 +112,10 @@ module RuboCop
         end
 
         def corrected_code(node)
-          lhs, operator, rhs = *node
-          "#{rhs.source} #{reverse_comparison(operator)} #{lhs.source}"
+          lhs = node.receiver
+          rhs = node.first_argument
+
+          "#{rhs.source} #{reverse_comparison(node.method_name)} #{lhs.source}"
         end
 
         def actual_code_range(node)
@@ -126,13 +129,11 @@ module RuboCop
         end
 
         def non_equality_operator?(node)
-          _, operator, = *node
-          !EQUALITY_OPERATORS.include?(operator)
+          !EQUALITY_OPERATORS.include?(node.method_name)
         end
 
         def noncommutative_operator?(node)
-          _, operator, = *node
-          NONCOMMUTATIVE_OPERATORS.include?(operator)
+          NONCOMMUTATIVE_OPERATORS.include?(node.method_name)
         end
       end
     end

data/lib/rubocop/cop/util.rb

@@ -45,11 +45,9 @@ module RuboCop
         while node
           case node.type
           when :send
-            receiver, _method_name, _args = *node
-            node = receiver
+            node = node.receiver
           when :block
-            method, _args, _body = *node
-            node = method
+            node = node.send_node
           else
             break
           end

data/lib/rubocop/file_finder.rb

@@ -13,16 +13,16 @@ module RuboCop
       @root_level == path.to_s
     end
 
-    def find_file_upwards(filename, start_dir, use_home: false)
-      traverse_files_upwards(filename, start_dir, use_home) do |file|
+    def find_file_upwards(filename, start_dir)
+      traverse_files_upwards(filename, start_dir) do |file|
         # minimize iteration for performance
         return file if file
       end
     end
 
-    def find_files_upwards(filename, start_dir, use_home: false)
+    def find_files_upwards(filename, start_dir)
       files = []
-      traverse_files_upwards(filename, start_dir, use_home) do |file|
+      traverse_files_upwards(filename, start_dir) do |file|
         files << file
       end
       files
@@ -30,18 +30,13 @@ module RuboCop
 
     private
 
-    def traverse_files_upwards(filename, start_dir, use_home)
+    def traverse_files_upwards(filename, start_dir)
       Pathname.new(start_dir).expand_path.ascend do |dir|
         break if FileFinder.root_level?(dir)
 
         file = dir + filename
         yield(file.to_s) if file.exist?
       end
-
-      return unless use_home && ENV.key?('HOME')
-
-      file = File.join(Dir.home, filename)
-      yield(file) if File.exist?(file)
     end
   end
 end

data/lib/rubocop/formatter/disabled_config_formatter.rb

@@ -58,6 +58,11 @@ module RuboCop
 
       def command
         command = 'rubocop --auto-gen-config'
+
+        if @options[:auto_gen_only_exclude]
+          command += ' --auto-gen-only-exclude'
+        end
+
         if @exclude_limit_option
           command +=
             format(' --exclude-limit %<limit>d',

data/lib/rubocop/node_pattern.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'delegate'
+require 'erb'
+
 # rubocop:disable Metrics/ClassLength, Metrics/CyclomaticComplexity
 module RuboCop
   # This class performs a pattern-matching operation on an AST node.
@@ -38,6 +41,12 @@ module RuboCop
   #     '$(send const ...)' # arbitrary matching can be performed on a capture
   #     '(send _recv _msg)' # wildcards can be named (for readability)
   #     '(send ... :new)'   # you can match against the last children
+  #     '(array <str sym>)' # you can match children in any order. This
+  #                         # would match `['x', :y]` as well as `[:y, 'x']
+  #     '(_ <str sym ...>)' # will match if arguments have at least a `str` and
+  #                         # a `sym` node, but can have more.
+  #     '(array <$str $_>)' # captures are in the order of the pattern,
+  #                         # irrespective of the actual order of the children
   #     '(send $...)'       # capture all the children as an array
   #     '(send $... int)'   # capture all children but the last as an array
   #     '(send _x :+ _x)'   # unification is performed on named wildcards
@@ -97,7 +106,7 @@ module RuboCop
     class Compiler
       SYMBOL       = %r{:(?:[\w+@*/?!<>=~|%^-]+|\[\]=?)}.freeze
       IDENTIFIER   = /[a-zA-Z_][a-zA-Z0-9_-]*/.freeze
-      META         = /\(|\)|\{|\}|\[|\]|\$\.\.\.|\$|!|\^|\.\.\./.freeze
+      META         = Regexp.union(%w"( ) { } [ ] $< < > $... $ ! ^ ...").freeze
       NUMBER       = /-?\d+(?:\.\d+)?/.freeze
       STRING       = /".+?"/.freeze
       METHOD_NAME  = /\#?#{IDENTIFIER}[\!\?]?\(?/.freeze
@@ -121,10 +130,36 @@ module RuboCop
       REST      = '...'.freeze
       CAPTURED_REST = '$...'.freeze
 
-      attr_reader :match_code
+      attr_reader :match_code, :tokens, :captures
 
       SEQ_HEAD_INDEX = -1
 
+      # Placeholders while compiling, see with_..._context methods
+      CUR_PLACEHOLDER = '@@@cur'.freeze
+      CUR_NODE = "#{CUR_PLACEHOLDER} node@@@".freeze
+      CUR_ELEMENT = "#{CUR_PLACEHOLDER} element@@@".freeze
+      SEQ_HEAD_GUARD = '@@@seq guard head@@@'.freeze
+
+      line = __LINE__
+      ANY_ORDER_TEMPLATE = ERB.new <<-RUBY.strip_indent.gsub("-%>\n", '%>')
+        <% if capture_rest %>(<%= capture_rest %> = []) && <% end -%>
+        <% if capture_all %>(<%= capture_all %> = <% end -%>
+        <%= CUR_NODE %>.children[<%= range %>]<% if capture_all %>)<% end -%>
+        .each_with_object({}) { |<%= child %>, <%= matched %>|
+          case
+          <% patterns.each_with_index do |pattern, i| -%>
+          when !<%= matched %>[<%= i %>] && <%=
+            with_context(pattern, child, use_temp_node: false)
+          %> then <%= matched %>[<%= i %>] = true
+          <% end -%>
+          <% if !rest %>  else break({})
+          <% elsif capture_rest %>  else <%= capture_rest %> << <%= child %>
+          <% end -%>
+          end
+        }.size == <%= patterns.size -%>
+      RUBY
+      ANY_ORDER_TEMPLATE.location = [__FILE__, line + 1]
+
       def initialize(str, node_var = 'node0')
         @string   = str
         @root     = node_var
@@ -133,40 +168,45 @@ module RuboCop
         @captures = 0  # number of captures seen
         @unify    = {} # named wildcard -> temp variable number
         @params   = 0  # highest % (param) number seen
-
         run(node_var)
       end
 
       def run(node_var)
-        tokens = Compiler.tokens(@string)
+        @tokens = Compiler.tokens(@string)
 
-        @match_code = compile_expr(tokens, node_var, false)
+        @match_code = with_context(compile_expr, node_var, use_temp_node: false)
+        @match_code.prepend("(captures = Array.new(#{@captures})) && ") \
+          if @captures > 0
 
         fail_due_to('unbalanced pattern') unless tokens.empty?
       end
 
       # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-      def compile_expr(tokens, cur_node, seq_head)
+      def compile_expr(token = tokens.shift)
         # read a single pattern-matching expression from the token stream,
         # return Ruby code which performs the corresponding matching operation
-        # on 'cur_node' (which is Ruby code which evaluates to an AST node)
         #
         # the 'pattern-matching' expression may be a composite which
-        # contains an arbitrary number of sub-expressions
-        token = tokens.shift
+        # contains an arbitrary number of sub-expressions, but that composite
+        # must all have precedence higher or equal to that of `&&`
+        #
+        # Expressions may use placeholders like:
+        #   CUR_NODE: Ruby code that evaluates to an AST node
+        #   CUR_ELEMENT: Either the node or the type if in first element of
+        #   a sequence (aka seq_head, e.g. "(seq_head first_node_arg ...")
         case token
-        when '('       then compile_seq(tokens, cur_node, seq_head)
-        when '{'       then compile_union(tokens, cur_node, seq_head)
-        when '['       then compile_intersect(tokens, cur_node, seq_head)
-        when '!'       then compile_negation(tokens, cur_node, seq_head)
-        when '$'       then compile_capture(tokens, cur_node, seq_head)
-        when '^'       then compile_ascend(tokens, cur_node, seq_head)
-        when WILDCARD  then compile_wildcard(cur_node, token[1..-1], seq_head)
-        when FUNCALL   then compile_funcall(tokens, cur_node, token, seq_head)
-        when LITERAL   then compile_literal(cur_node, token, seq_head)
-        when PREDICATE then compile_predicate(tokens, cur_node, token, seq_head)
-        when NODE      then compile_nodetype(cur_node, token)
-        when PARAM     then compile_param(cur_node, token[1..-1], seq_head)
+        when '('       then compile_seq
+        when '{'       then compile_union
+        when '['       then compile_intersect
+        when '!'       then compile_negation
+        when '$'       then compile_capture
+        when '^'       then compile_ascend
+        when WILDCARD  then compile_wildcard(token[1..-1])
+        when FUNCALL   then compile_funcall(token)
+        when LITERAL   then compile_literal(token)
+        when PREDICATE then compile_predicate(token)
+        when NODE      then compile_nodetype(token)
+        when PARAM     then compile_param(token[1..-1])
         when CLOSING   then fail_due_to("#{token} in invalid position")
         when nil       then fail_due_to('pattern ended prematurely')
         else                fail_due_to("invalid token #{token.inspect}")
@@ -174,211 +214,260 @@ module RuboCop
       end
       # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
-      def compile_seq(tokens, cur_node, seq_head)
-        fail_due_to('empty parentheses') if tokens.first == ')'
-        fail_due_to('parentheses at sequence head') if seq_head
+      def tokens_until(stop, what)
+        return to_enum __method__, stop, what unless block_given?
 
-        # 'cur_node' is a Ruby expression which evaluates to an AST node,
-        # but we don't know how expensive it is
-        # to be safe, cache the node in a temp variable and then use the
-        # temp variable as 'cur_node'
-        with_temp_node(cur_node) do |init, temp_node|
-          terms = compile_seq_terms(tokens, temp_node)
-          terms.unshift(compile_guard_clause(temp_node))
+        fail_due_to("empty #{what}") if tokens.first == stop && what
+        yield until tokens.first == stop
+        tokens.shift
+      end
 
-          join_terms(init, terms, " &&\n")
-        end
+      def compile_seq
+        terms = tokens_until(')', 'sequence').map { variadic_seq_term }
+        Sequence.new(self, *terms).compile
       end
 
-      def compile_guard_clause(cur_node)
-        "#{cur_node}.is_a?(RuboCop::AST::Node)"
+      def compile_guard_clause
+        "#{CUR_NODE}.is_a?(RuboCop::AST::Node)"
       end
 
-      def compile_seq_terms(tokens, cur_node)
-        ret =
-          compile_seq_terms_with_size(tokens, cur_node) do |token, terms, index|
-            capture = next_capture if token == CAPTURED_REST
-            if capture || token == REST
-              index = 0 if index == SEQ_HEAD_INDEX # Consider ($...) as (_ $...)
-              return compile_ellipsis(tokens, cur_node, terms, index, capture)
-            end
-          end
-        ret << "(#{cur_node}.children.size == #{ret.size - 1})"
+      def variadic_seq_term
+        token = tokens.shift
+        case token
+        when CAPTURED_REST then compile_captured_ellipsis
+        when REST          then compile_ellipsis
+        when '$<'          then compile_any_order(next_capture)
+        when '<'           then compile_any_order
+        else                    [1, compile_expr(token)]
+        end
       end
 
-      def compile_seq_terms_with_size(tokens, cur_node)
-        index = SEQ_HEAD_INDEX
-        terms = []
-        until tokens.first == ')'
-          yield tokens.first, terms, index
-          term = compile_expr_with_index(tokens, cur_node, index)
-          index += 1
-          terms << term
+      # @private
+      # Builds Ruby code for a sequence
+      # (head *first_terms variadic_term *last_terms)
+      class Sequence < SimpleDelegator
+        def initialize(compiler, *arity_term_list)
+          @arities, @terms = arity_term_list.transpose
+
+          super(compiler)
+          @variadic_index = @arities.find_index { |a| a.is_a?(Range) }
+          fail_due_to 'multiple variable patterns in same sequence' \
+            if @variadic_index && !@arities.one? { |a| a.is_a?(Range) }
         end
 
-        tokens.shift # drop concluding )
-        terms
-      end
+        def compile
+          [
+            compile_guard_clause,
+            compile_child_nb_guard,
+            compile_seq_head,
+            *compile_first_terms,
+            compile_variadic_term,
+            *compile_last_terms
+          ].compact.join(" &&\n") << SEQ_HEAD_GUARD
+        end
 
-      def compile_expr_with_index(tokens, cur_node, index)
-        if index == SEQ_HEAD_INDEX
-          # in 'sequence head' position; some expressions are compiled
-          # differently at 'sequence head' (notably 'node type' expressions)
-          # grep for seq_head to see where it makes a difference
-          compile_expr(tokens, cur_node, true)
-        else
-          child_node = "#{cur_node}.children[#{index}]"
-          compile_expr(tokens, child_node, false)
+        private
+
+        def first_terms_arity
+          first_terms_range { |r| @arities[r].inject(0, :+) } || 0
         end
-      end
 
-      def compile_ellipsis(tokens, cur_node, terms, index, capture = nil)
-        tokens.shift # drop ellipsis
-        tail = compile_seq_tail(tokens, cur_node)
-        terms << "(#{cur_node}.children.size >= #{index + tail.size})"
-        terms.concat tail
-        if capture
-          range = index..-tail.size - 1
-          terms << "(#{capture} = #{cur_node}.children[#{range}])"
+        def last_terms_arity
+          last_terms_range { |r| @arities[r].inject(0, :+) } || 0
         end
-        terms
-      end
 
-      def compile_seq_tail(tokens, cur_node)
-        child_node = "#{cur_node}.children[%<revindex>i]"
-        terms = []
-        until tokens.first == ')'
-          terms << compile_expr(tokens, child_node, false)
+        def first_terms_range
+          yield 1..(@variadic_index || @terms.size) - 1 if seq_head?
         end
-        tokens.shift # drop ')'
-        # E.g. for terms.size == 3, we want to replace the three [%<revindex>i]
-        # with [-3], [-2] and [-1]
-        terms.map.with_index { |term, i| format term, revindex: i - terms.size }
-      end
 
-      def compile_union(tokens, cur_node, seq_head)
-        fail_due_to('empty union') if tokens.first == '}'
+        def last_terms_range
+          yield @variadic_index + 1...@terms.size if @variadic_index
+        end
 
-        with_temp_node(cur_node) do |init, temp_node|
-          terms = union_terms(tokens, temp_node, seq_head)
-          join_terms(init, terms, ' || ')
+        def seq_head?
+          @variadic_index != 0
         end
-      end
 
-      def union_terms(tokens, temp_node, seq_head)
-        # we need to ensure that each branch of the {} contains the same
-        # number of captures (since only one branch of the {} can actually
-        # match, the same variables are used to hold the captures for each
-        # branch)
-        compile_expr_with_captures(tokens,
-                                   temp_node, seq_head) do |term, before, after|
-          terms = [term]
-          until tokens.first == '}'
-            terms << compile_expr_with_capture_check(tokens, temp_node,
-                                                     seq_head, before, after)
+        def compile_child_nb_guard
+          min = first_terms_arity + last_terms_arity
+          "#{CUR_NODE}.children.size #{@variadic_index ? '>' : '='}= #{min}"
+        end
+
+        def term(index, range)
+          t = @terms[index]
+          if t.respond_to? :call
+            t.call(range)
+          else
+            with_child_context(t, range.begin)
           end
-          tokens.shift
+        end
+
+        def compile_seq_head
+          return unless seq_head?
+
+          fail_due_to 'sequences can not start with <' \
+            if @terms[0].respond_to? :call
 
-          terms
+          with_seq_head_context(@terms[0])
         end
-      end
 
-      def compile_expr_with_captures(tokens, temp_node, seq_head)
-        captures_before = @captures
-        expr = compile_expr(tokens, temp_node, seq_head)
+        def compile_first_terms
+          first_terms_range { |range| compile_terms(range, 0) }
+        end
 
-        yield expr, captures_before, @captures
-      end
+        def compile_last_terms
+          last_terms_range { |r| compile_terms(r, -last_terms_arity) }
+        end
 
-      def compile_expr_with_capture_check(tokens, temp_node, seq_head, before,
-                                          after)
-        @captures = before
-        expr = compile_expr(tokens, temp_node, seq_head)
-        if @captures != after
-          fail_due_to('each branch of {} must have same # of captures')
+        def compile_terms(index_range, start)
+          index_range.map do |i|
+            current = start
+            start += @arities.fetch(i)
+            term(i, current..start - 1)
+          end
         end
 
-        expr
-      end
+        def compile_variadic_term
+          variadic_arity { |arity| term(@variadic_index, arity) }
+        end
 
-      def compile_intersect(tokens, cur_node, seq_head)
-        fail_due_to('empty intersection') if tokens.first == ']'
+        def variadic_arity
+          return unless @variadic_index
 
-        with_temp_node(cur_node) do |init, temp_node|
-          terms = []
-          until tokens.first == ']'
-            terms << compile_expr(tokens, temp_node, seq_head)
+          first = @variadic_index > 0 ? first_terms_arity : SEQ_HEAD_INDEX
+          yield first..-last_terms_arity - 1
+        end
+      end
+      private_constant :Sequence
+
+      def compile_captured_ellipsis
+        capture = next_capture
+        block = lambda { |range|
+          # Consider ($...) like (_ $...):
+          range = 0..range.end if range.begin == SEQ_HEAD_INDEX
+          "(#{capture} = #{CUR_NODE}.children[#{range}])"
+        }
+        [0..Float::INFINITY, block]
+      end
+
+      def compile_ellipsis
+        [0..Float::INFINITY, 'true']
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def compile_any_order(capture_all = nil)
+        rest = capture_rest = nil
+        patterns = []
+        with_temp_variables do |child, matched|
+          tokens_until('>', 'any child').each do
+            fail_due_to 'ellipsis must be at the end of <>' if rest
+            token = tokens.shift
+            case token
+            when CAPTURED_REST then rest = capture_rest = next_capture
+            when REST          then rest = true
+            else patterns << compile_expr(token)
+            end
           end
-          tokens.shift
+          [rest ? patterns.size..Float::INFINITY : patterns.size,
+           ->(range) { ANY_ORDER_TEMPLATE.result(binding) }]
+        end
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def insure_same_captures(enum, what)
+        return to_enum __method__, enum, what unless block_given?
 
-          join_terms(init, terms, ' && ')
+        captures_before = captures_after = nil
+        enum.each do
+          captures_before ||= @captures
+          @captures = captures_before
+          yield
+          captures_after ||= @captures
+          if captures_after != @captures
+            fail_due_to("each #{what} must have same # of captures")
+          end
         end
       end
 
-      def compile_capture(tokens, cur_node, seq_head)
-        "(#{next_capture} = #{cur_node}#{'.type' if seq_head}; " \
-          "#{compile_expr(tokens, cur_node, seq_head)})"
+      def compile_union
+        # we need to ensure that each branch of the {} contains the same
+        # number of captures (since only one branch of the {} can actually
+        # match, the same variables are used to hold the captures for each
+        # branch)
+        enum = tokens_until('}', 'union')
+        terms = insure_same_captures(enum, 'branch of {}')
+                .map { compile_expr }
+
+        "(#{terms.join(' || ')})"
+      end
+
+      def compile_intersect
+        tokens_until(']', 'intersection')
+          .map { compile_expr }
+          .join(' && ')
       end
 
-      def compile_negation(tokens, cur_node, seq_head)
-        "(!#{compile_expr(tokens, cur_node, seq_head)})"
+      def compile_capture
+        "(#{next_capture} = #{CUR_ELEMENT}; #{compile_expr})"
       end
 
-      def compile_ascend(tokens, cur_node, seq_head)
-        "(#{cur_node}.parent && " \
-          "#{compile_expr(tokens, "#{cur_node}.parent", seq_head)})"
+      def compile_negation
+        "!(#{compile_expr})"
       end
 
-      def compile_wildcard(cur_node, name, seq_head)
+      def compile_ascend
+        with_context("#{CUR_NODE} && #{compile_expr}", "#{CUR_NODE}.parent")
+      end
+
+      def compile_wildcard(name)
         if name.empty?
           'true'
         elsif @unify.key?(name)
           # we have already seen a wildcard with this name before
           # so the value it matched the first time will already be stored
           # in a temp. check if this value matches the one stored in the temp
-          "(#{cur_node}#{'.type' if seq_head} == temp#{@unify[name]})"
+          "#{CUR_ELEMENT} == temp#{@unify[name]}"
         else
           n = @unify[name] = next_temp_value
           # double assign to temp#{n} to avoid "assigned but unused variable"
-          "(temp#{n} = #{cur_node}#{'.type' if seq_head}; " \
+          "(temp#{n} = #{CUR_ELEMENT}; " \
           "temp#{n} = temp#{n}; true)"
         end
       end
 
-      def compile_literal(cur_node, literal, seq_head)
-        "(#{cur_node}#{'.type' if seq_head} == #{literal})"
+      def compile_literal(literal)
+        "#{CUR_ELEMENT} == #{literal}"
       end
 
-      def compile_predicate(tokens, cur_node, predicate, seq_head)
+      def compile_predicate(predicate)
         if predicate.end_with?('(') # is there an arglist?
           args = compile_args(tokens)
           predicate = predicate[0..-2] # drop the trailing (
-          "(#{cur_node}#{'.type' if seq_head}.#{predicate}(#{args.join(',')}))"
+          "#{CUR_ELEMENT}.#{predicate}(#{args.join(',')})"
         else
-          "(#{cur_node}#{'.type' if seq_head}.#{predicate})"
+          "#{CUR_ELEMENT}.#{predicate}"
         end
       end
 
-      def compile_funcall(tokens, cur_node, method, seq_head)
+      def compile_funcall(method)
         # call a method in the context which this pattern-matching
         # code is used in. pass target value as an argument
         method = method[1..-1] # drop the leading #
         if method.end_with?('(') # is there an arglist?
           args = compile_args(tokens)
           method = method[0..-2] # drop the trailing (
-          "(#{method}(#{cur_node}#{'.type' if seq_head},#{args.join(',')}))"
+          "#{method}(#{CUR_ELEMENT},#{args.join(',')})"
         else
-          "(#{method}(#{cur_node}#{'.type' if seq_head}))"
+          "#{method}(#{CUR_ELEMENT})"
         end
       end
 
-      def compile_nodetype(cur_node, type)
-        "(#{cur_node}.is_a?(RuboCop::AST::Node) && " \
-          "#{cur_node}.#{type.tr('-', '_')}_type?)"
+      def compile_nodetype(type)
+        "#{compile_guard_clause} && #{CUR_NODE}.#{type.tr('-', '_')}_type?"
       end
 
-      def compile_param(cur_node, number, seq_head)
-        "(#{cur_node}#{'.type' if seq_head} == #{get_param(number)})"
+      def compile_param(number)
+        "#{CUR_ELEMENT} == #{get_param(number)}"
       end
 
       def compile_args(tokens)
@@ -406,7 +495,9 @@ module RuboCop
       end
 
       def next_capture
-        "capture#{@captures += 1}"
+        index = @captures
+        @captures += 1
+        "captures[#{index}]"
       end
 
       def get_param(number)
@@ -415,21 +506,24 @@ module RuboCop
         number.zero? ? @root : "param#{number}"
       end
 
-      def join_terms(init, terms, operator)
-        "(#{init};#{terms.join(operator)})"
-      end
-
-      def emit_capture_list
-        (1..@captures).map { |n| "capture#{n}" }.join(',')
+      def emit_yield_capture(when_no_capture = '')
+        yield_val = if @captures.zero?
+                      when_no_capture
+                    elsif @captures == 1
+                      'captures[0]' # Circumvent https://github.com/jruby/jruby/issues/5710
+                    else
+                      '*captures'
+                    end
+        "yield(#{yield_val})"
       end
 
       def emit_retval
         if @captures.zero?
           'true'
         elsif @captures == 1
-          'capture1'
+          'captures[0]'
         else
-          "[#{emit_capture_list}]"
+          'captures'
         end
       end
 
@@ -445,7 +539,7 @@ module RuboCop
       def emit_method_code
         <<-RUBY
           return unless #{@match_code}
-          block_given? ? yield(#{emit_capture_list}) : (return #{emit_retval})
+          block_given? ? #{emit_yield_capture} : (return #{emit_retval})
         RUBY
       end
 
@@ -454,20 +548,62 @@ module RuboCop
       end
 
       def with_temp_node(cur_node)
-        with_temp_variable do |temp_var|
-          # double assign to temp#{n} to avoid "assigned but unused variable"
-          yield "#{temp_var} = #{cur_node}; #{temp_var} = #{temp_var}", temp_var
+        with_temp_variables do |node|
+          yield "(#{node} = #{cur_node})", node
         end
+          .gsub("\n", "\n  ") # Nicer indent for debugging
       end
 
-      def with_temp_variable
-        yield "temp#{next_temp_value}"
+      def with_temp_variables(&block)
+        names = block.parameters.map { |_, name| "#{name}#{next_temp_value}" }
+        yield(*names)
       end
 
       def next_temp_value
         @temps += 1
       end
 
+      def auto_use_temp_node?(code)
+        code.scan(CUR_PLACEHOLDER).count > 1
+      end
+
+      # with_<...>_context methods are used whenever the context,
+      # i.e the current node or the current element can be determined.
+
+      def with_child_context(code, child_index)
+        with_context(code, "#{CUR_NODE}.children[#{child_index}]")
+      end
+
+      def with_context(code, cur_node,
+                       use_temp_node: auto_use_temp_node?(code))
+        if use_temp_node
+          with_temp_node(cur_node) do |init, temp_var|
+            substitute_cur_node(code, temp_var, first_cur_node: init)
+          end
+        else
+          substitute_cur_node(code, cur_node)
+        end
+      end
+
+      def with_seq_head_context(code)
+        if code.include?(SEQ_HEAD_GUARD)
+          fail_due_to('parentheses at sequence head')
+        end
+
+        code.gsub CUR_ELEMENT, "#{CUR_NODE}.type"
+      end
+
+      def substitute_cur_node(code, cur_node, first_cur_node: cur_node)
+        iter = 0
+        code
+          .gsub(CUR_ELEMENT, CUR_NODE)
+          .gsub(CUR_NODE) do
+            iter += 1
+            iter == 1 ? first_cur_node : cur_node
+          end
+          .gsub(SEQ_HEAD_GUARD, '')
+      end
+
       def self.tokens(pattern)
         pattern.scan(TOKEN).reject { |token| token =~ /\A#{SEPARATORS}\Z/ }
       end
@@ -515,13 +651,11 @@ module RuboCop
       end
 
       def node_search_all(method_name, compiler, called_from)
-        yieldval = compiler.emit_capture_list
-        yieldval = 'node' if yieldval.empty?
+        yield_code = compiler.emit_yield_capture('node')
         prelude = "return enum_for(:#{method_name}, node0" \
                   "#{compiler.emit_trailing_params}) unless block_given?"
 
-        node_search(method_name, compiler, "yield(#{yieldval})", prelude,
-                    called_from)
+        node_search(method_name, compiler, yield_code, prelude, called_from)
       end
 
       def node_search(method_name, compiler, on_match, prelude, called_from)