rubocop 0.42.0 → 0.52.1

data/lib/rubocop/node_pattern.rb

@@ -1,9 +1,6 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/ClassLength
-# rubocop:disable Metrics/CyclomaticComplexity
-
+# rubocop:disable Metrics/ClassLength, Metrics/CyclomaticComplexity
 module RuboCop
   # This class performs a pattern-matching operation on an AST node.
   #
@@ -20,58 +17,59 @@ module RuboCop
   #               value of the block through.
   # - With no block, but one capture: the capture is returned.
   # - With no block, but multiple captures: captures are returned as an array.
-  # - With no captures: #match returns `true`.
+  # - With no block and no captures: #match returns `true`.
   #
   # ## Pattern string format examples
   #
-  #    ':sym'              # matches a literal symbol
-  #    '1'                 # matches a literal integer
-  #    'nil'               # matches a literal nil
-  #    'send'              # matches (send ...)
-  #    '(send)'            # matches (send)
-  #    '(send ...)'        # matches (send ...)
-  #    '{send class}'      # matches (send ...) or (class ...)
-  #    '({send class})'    # matches (send) or (class)
-  #    '(send const)'      # matches (send (const ...))
-  #    '(send _ :new)'     # matches (send <anything> :new)
-  #    '(send $_ :new)'    # as above, but whatever matches the $_ is captured
-  #    '(send $_ $_)'      # you can use as many captures as you want
-  #    '(send !const ...)' # ! negates the next part of the pattern
-  #    '$(send const ...)' # arbitrary matching can be performed on a capture
-  #    '(send _recv _msg)' # wildcards can be named (for readability)
-  #    '(send ... :new)'   # you can specifically match against the last child
-  #                        # (this only works for the very last)
-  #    '(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
-  #                        # (like Prolog variables...)
-  #                        # (#== is used to see if values unify)
-  #    '(int odd?)'        # words which end with a ? are predicate methods,
-  #                        # are are called on the target to see if it matches
-  #                        # any Ruby method which the matched object supports
-  #                        # can be used
-  #                        # if a truthy value is returned, the match succeeds
-  #    '(int [!1 !2])'     # [] contains multiple patterns, ALL of which must
-  #                        # match in that position
-  #                        # in other words, while {} is pattern union (logical
-  #                        # OR), [] is intersection (logical AND)
-  #    '(send %1 _)'       # % stands for a parameter which must be supplied to
-  #                        # #match at matching time
-  #                        # it will be compared to the corresponding value in
-  #                        # the AST using #==
-  #                        # a bare '%' is the same as '%1'
-  #                        # the number of extra parameters passed to #match
-  #                        # must equal the highest % value in the pattern
-  #                        # for consistency, %0 is the 'root node' which is
-  #                        # passed as the 1st argument to #match, where the
-  #                        # matching process starts
-  #    '^^send'            # each ^ ascends one level in the AST
-  #                        # so this matches against the grandparent node
-  #    '#method'           # we call this a 'funcall'; it calls a method in the
-  #                        # context where a pattern-matching method is defined
-  #                        # if that returns a truthy value, the match succeeds
-  #    'equal?(%1)'        # predicates can be given 1 or more extra args
-  #    '#method(%0, 1)'    # funcalls can also be given 1 or more extra args
+  #     ':sym'              # matches a literal symbol
+  #     '1'                 # matches a literal integer
+  #     'nil'               # matches a literal nil
+  #     'send'              # matches (send ...)
+  #     '(send)'            # matches (send)
+  #     '(send ...)'        # matches (send ...)
+  #     '(op-asgn)'         # node types with hyphenated names also work
+  #     '{send class}'      # matches (send ...) or (class ...)
+  #     '({send class})'    # matches (send) or (class)
+  #     '(send const)'      # matches (send (const ...))
+  #     '(send _ :new)'     # matches (send <anything> :new)
+  #     '(send $_ :new)'    # as above, but whatever matches the $_ is captured
+  #     '(send $_ $_)'      # you can use as many captures as you want
+  #     '(send !const ...)' # ! negates the next part of the pattern
+  #     '$(send const ...)' # arbitrary matching can be performed on a capture
+  #     '(send _recv _msg)' # wildcards can be named (for readability)
+  #     '(send ... :new)'   # you can specifically match against the last child
+  #                         # (this only works for the very last)
+  #     '(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
+  #                         # (like Prolog variables...)
+  #                         # (#== is used to see if values unify)
+  #     '(int odd?)'        # words which end with a ? are predicate methods,
+  #                         # are are called on the target to see if it matches
+  #                         # any Ruby method which the matched object supports
+  #                         # can be used
+  #                         # if a truthy value is returned, the match succeeds
+  #     '(int [!1 !2])'     # [] contains multiple patterns, ALL of which must
+  #                         # match in that position
+  #                         # in other words, while {} is pattern union (logical
+  #                         # OR), [] is intersection (logical AND)
+  #     '(send %1 _)'       # % stands for a parameter which must be supplied to
+  #                         # #match at matching time
+  #                         # it will be compared to the corresponding value in
+  #                         # the AST using #==
+  #                         # a bare '%' is the same as '%1'
+  #                         # the number of extra parameters passed to #match
+  #                         # must equal the highest % value in the pattern
+  #                         # for consistency, %0 is the 'root node' which is
+  #                         # passed as the 1st argument to #match, where the
+  #                         # matching process starts
+  #     '^^send'            # each ^ ascends one level in the AST
+  #                         # so this matches against the grandparent node
+  #     '#method'           # we call this a 'funcall'; it calls a method in the
+  #                         # context where a pattern-matching method is defined
+  #                         # if that returns a truthy value, the match succeeds
+  #     'equal?(%1)'        # predicates can be given 1 or more extra args
+  #     '#method(%0, 1)'    # funcalls can also be given 1 or more extra args
   #
   # You can nest arbitrarily deep:
   #
@@ -98,19 +96,26 @@ module RuboCop
     # @private
     # Builds Ruby code which implements a pattern
     class Compiler
-      RSYM    = %r{:(?:[\w+@_*/?!<>=~|%^-]+|\[\]=?)}
-      ID_CHAR = /[a-zA-Z_]/
-      META    = /\(|\)|\{|\}|\[|\]|\$\.\.\.|\$|!|\^|\.\.\./
-      NUMBER  = /-?\d+(?:\.\d+)?/
-      TOKEN   =
-        /\G(?:[\s,]+|#{META}|\#?#{ID_CHAR}+[\!\?]?\(?|%\d*|#{NUMBER}|#{RSYM}|.)/
-
-      NODE      = /\A#{ID_CHAR}+\Z/
-      PREDICATE = /\A#{ID_CHAR}+\?\(?\Z/
-      WILDCARD  = /\A_#{ID_CHAR}*\Z/
-      FUNCALL   = /\A\##{ID_CHAR}+[\!\?]?\(?\Z/
-      LITERAL   = /\A(?:#{RSYM}|#{NUMBER}|nil)\Z/
-      PARAM     = /\A%\d*\Z/
+      SYMBOL       = %r{:(?:[\w+@*/?!<>=~|%^-]+|\[\]=?)}
+      IDENTIFIER   = /[a-zA-Z_-]/
+      META         = /\(|\)|\{|\}|\[|\]|\$\.\.\.|\$|!|\^|\.\.\./
+      NUMBER       = /-?\d+(?:\.\d+)?/
+      STRING       = /".+?"/
+      METHOD_NAME  = /\#?#{IDENTIFIER}+[\!\?]?\(?/
+      PARAM_NUMBER = /%\d*/
+
+      SEPARATORS = /[\s]+/
+      TOKENS     = Regexp.union(META, PARAM_NUMBER, NUMBER,
+                                METHOD_NAME, SYMBOL, STRING)
+
+      TOKEN = /\G(?:#{SEPARATORS}|#{TOKENS}|.)/
+
+      NODE      = /\A#{IDENTIFIER}+\Z/
+      PREDICATE = /\A#{IDENTIFIER}+\?\(?\Z/
+      WILDCARD  = /\A_#{IDENTIFIER}*\Z/
+      FUNCALL   = /\A\##{METHOD_NAME}/
+      LITERAL   = /\A(?:#{SYMBOL}|#{NUMBER}|#{STRING})\Z/
+      PARAM     = /\A#{PARAM_NUMBER}\Z/
       CLOSING   = /\A(?:\)|\}|\])\Z/
 
       attr_reader :match_code
@@ -128,9 +133,11 @@ module RuboCop
       end
 
       def run(node_var)
-        tokens = @string.scan(TOKEN)
-        tokens.reject! { |token| token =~ /\A[\s,]+\Z/ } # drop whitespace
+        tokens =
+          @string.scan(TOKEN).reject { |token| token =~ /\A#{SEPARATORS}\Z/ }
+
         @match_code = compile_expr(tokens, node_var, false)
+
         fail_due_to('unbalanced pattern') unless tokens.empty?
       end
 
@@ -158,7 +165,7 @@ module RuboCop
         when PARAM     then compile_param(cur_node, token[1..-1], seq_head)
         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}")
+        else                fail_due_to("invalid token #{token.inspect}")
         end
       end
       # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
@@ -171,15 +178,15 @@ module RuboCop
         # 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'
-        init = "temp#{@temps += 1} = #{cur_node}"
-        cur_node = "temp#{@temps}"
-        terms = compile_seq_terms(tokens, cur_node)
+        with_temp_node(cur_node) do |init, temp_node|
+          terms = compile_seq_terms(tokens, temp_node)
 
-        join_terms(init, terms, ' && ')
+          join_terms(init, terms, ' && ')
+        end
       end
 
       def compile_seq_terms(tokens, cur_node)
-        terms, size =
+        ret, size =
           compile_seq_terms_with_size(tokens, cur_node) do |token, terms, index|
             case token
             when '...'.freeze
@@ -189,7 +196,7 @@ module RuboCop
             end
           end
 
-        terms << "(#{cur_node}.children.size == #{size})"
+        ret << "(#{cur_node}.children.size == #{size})"
       end
 
       def compile_seq_terms_with_size(tokens, cur_node)
@@ -255,43 +262,60 @@ module RuboCop
       def compile_union(tokens, cur_node, seq_head)
         fail_due_to('empty union') if tokens.first == '}'
 
-        init = "temp#{@temps += 1} = #{cur_node}"
-        cur_node = "temp#{@temps}"
+        with_temp_node(cur_node) do |init, temp_node|
+          terms = union_terms(tokens, temp_node, seq_head)
+          join_terms(init, terms, ' || ')
+        end
+      end
 
-        terms = []
+      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)
-        captures_before = @captures
-        terms << compile_expr(tokens, cur_node, seq_head)
-        captures_after = @captures
-
-        until tokens.first == '}'
-          @captures = captures_before
-          terms << compile_expr(tokens, cur_node, seq_head)
-          if @captures != captures_after
-            fail_due_to('each branch of {} must have same # of captures')
+        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)
           end
+          tokens.shift
+
+          terms
+        end
+      end
+
+      def compile_expr_with_captures(tokens, temp_node, seq_head)
+        captures_before = @captures
+        expr = compile_expr(tokens, temp_node, seq_head)
+
+        yield expr, captures_before, @captures
+      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')
         end
-        tokens.shift
 
-        join_terms(init, terms, ' || ')
+        expr
       end
 
       def compile_intersect(tokens, cur_node, seq_head)
         fail_due_to('empty intersection') if tokens.first == ']'
 
-        init = "temp#{@temps += 1} = #{cur_node}"
-        cur_node = "temp#{@temps}"
+        with_temp_node(cur_node) do |init, temp_node|
+          terms = []
+          until tokens.first == ']'
+            terms << compile_expr(tokens, temp_node, seq_head)
+          end
+          tokens.shift
 
-        terms = []
-        until tokens.first == ']'
-          terms << compile_expr(tokens, cur_node, seq_head)
+          join_terms(init, terms, ' && ')
         end
-        tokens.shift
-
-        join_terms(init, terms, ' && ')
       end
 
       def compile_capture(tokens, cur_node, seq_head)
@@ -317,8 +341,10 @@ module RuboCop
           # in a temp. check if this value matches the one stored in the temp
           "(#{cur_node}#{'.type' if seq_head} == temp#{@unify[name]})"
         else
-          n = @unify[name] = (@temps += 1)
-          "(temp#{n} = #{cur_node}#{'.type' if seq_head}; true)"
+          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} = temp#{n}; true)"
         end
       end
 
@@ -350,7 +376,7 @@ module RuboCop
       end
 
       def compile_nodetype(cur_node, type)
-        "(#{cur_node} && #{cur_node}.#{type}_type?)"
+        "(#{cur_node} && #{cur_node}.#{type.tr('-', '_')}_type?)"
       end
 
       def compile_param(cur_node, number, seq_head)
@@ -415,17 +441,39 @@ module RuboCop
         params.empty? ? '' : ",#{params}"
       end
 
+      def emit_guard_clause
+        <<-RUBY
+          return unless node.is_a?(RuboCop::AST::Node)
+        RUBY
+      end
+
       def emit_method_code
-        <<-CODE
-          return nil unless #{@match_code}
+        <<-RUBY
+          return unless #{@match_code}
           block_given? ? yield(#{emit_capture_list}) : (return #{emit_retval})
-        CODE
+        RUBY
       end
 
       def fail_due_to(message)
         raise Invalid, "Couldn't compile due to #{message}. Pattern: #{@string}"
       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
+        end
+      end
+
+      def with_temp_variable
+        yield "temp#{next_temp_value}"
+      end
+
+      def next_temp_value
+        @temps += 1
+      end
     end
+    private_constant :Compiler
 
     # Helpers for defining methods based on a pattern string
     module Macros
@@ -437,13 +485,14 @@ module RuboCop
       # If the node matches, and no block is provided, the new method will
       # return the captures, or `true` if there were none.
       def def_node_matcher(method_name, pattern_str)
-        compiler = RuboCop::NodePattern::Compiler.new(pattern_str, 'node')
-        src = "def #{method_name}(node" \
+        compiler = Compiler.new(pattern_str, 'node')
+        src = "def #{method_name}(node = self" \
               "#{compiler.emit_trailing_params});" \
+              "#{compiler.emit_guard_clause}" \
               "#{compiler.emit_method_code};end"
 
-        file, lineno = *caller.first.split(':')
-        class_eval(src, file, lineno.to_i)
+        location = caller_locations(1, 1).first
+        class_eval(src, location.path, location.lineno)
       end
 
       # Define a method which recurses over the descendants of an AST node,
@@ -453,27 +502,40 @@ module RuboCop
       # as soon as it finds a descendant which matches. Otherwise, it will
       # yield all descendants which match.
       def def_node_search(method_name, pattern_str)
-        compiler = RuboCop::NodePattern::Compiler.new(pattern_str, 'node')
+        compiler = Compiler.new(pattern_str, 'node')
+        called_from = caller(1..1).first.split(':')
+
         if method_name.to_s.end_with?('?')
-          on_match = 'return true'
-          prelude = ''
+          node_search_first(method_name, compiler, called_from)
         else
-          yieldval = compiler.emit_capture_list
-          yieldval = 'node' if yieldval.empty?
-          on_match = "yield(#{yieldval})"
-          prelude = "return enum_for(:#{method_name}, node0" \
-          "#{compiler.emit_trailing_params}) unless block_given?"
+          node_search_all(method_name, compiler, called_from)
         end
+      end
+
+      def node_search_first(method_name, compiler, called_from)
+        node_search(method_name, compiler, 'return true', '', called_from)
+      end
+
+      def node_search_all(method_name, compiler, called_from)
+        yieldval = compiler.emit_capture_list
+        yieldval = 'node' if yieldval.empty?
+        prelude = "return enum_for(:#{method_name}, node0" \
+                  "#{compiler.emit_trailing_params}) unless block_given?"
+
+        node_search(method_name, compiler, "yield(#{yieldval})", prelude,
+                    called_from)
+      end
 
+      def node_search(method_name, compiler, on_match, prelude, called_from)
         src = node_search_body(method_name, compiler.emit_trailing_params,
                                prelude, compiler.match_code, on_match)
-        filename, lineno = *caller.first.split(':')
+        filename, lineno = *called_from
         class_eval(src, filename, lineno.to_i)
       end
 
       def node_search_body(method_name, trailing_params, prelude, match_code,
                            on_match)
-        <<-END
+        <<-RUBY
           def #{method_name}(node0#{trailing_params})
             #{prelude}
             node0.each_node do |node|
@@ -483,7 +545,7 @@ module RuboCop
             end
             nil
           end
-        END
+        RUBY
       end
     end
 
@@ -495,3 +557,4 @@ module RuboCop
     end
   end
 end
+# rubocop:enable Metrics/ClassLength, Metrics/CyclomaticComplexity