rubocop-ast 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4108494066548a429e972d3f2afcaa9adfd39072a929308cdb20e4a602fef66d
-  data.tar.gz: 413b4382539bffed1760d0599bc093ad40ffef64992f821484994150903812da
+  metadata.gz: d213ca265b42f0b66394057ee01a4a4573a28da98e7fc8caf52b5396fe098381
+  data.tar.gz: 3a351df6a7f11cfdad47b7844eb0c0d9860e11e7fdd65f5e1405b1f0978081be
 SHA512:
-  metadata.gz: 97af9dd864e8f6867614a79b2aac596e18e147b9a55bcc67b8755e47ef762730ec69612dcc6858ee12017b33beae0b89e008e1267034f1730682015c4efa4255
-  data.tar.gz: 807305ab6dc90885fff96d1387d787debf8ce8f27a0d150ad4bf86a76d4afb2d288f0771b2399cf3c3cfb1472c72cd750e4df9e97ad07467da4615a97c062f79
+  metadata.gz: 1771b173896909ca2e9b68acf312c7b73e2e7308f834fc6d79871bd84b5012622e8727ab3e0cf98ca985cab32a70e65c83b174ff1bf42a59bba942720625b198
+  data.tar.gz: 57539ef58f3fc0722220759e4875524b43f9cd89a919d47429327f2ab3eaa2cfb0b35d9e275b05ac683f4f860bf5ac1986619fc16aa71c5a6b80ff2797683fa0

data/README.md

@@ -6,11 +6,12 @@
 [![Maintainability](https://api.codeclimate.com/v1/badges/a29666e6373bc41bc0a9/maintainability)](https://codeclimate.com/github/rubocop-hq/rubocop-ast/maintainability)
 
 Contains the classes needed by [RuboCop](https://github.com/rubocop-hq/rubocop) to deal with Ruby's AST, in particular:
-* `RuboCop::AST::Node`
+
+* `RuboCop::AST::Node` ([doc](docs/modules/ROOT/pages/node_types.adoc))
 * `RuboCop::AST::NodePattern` ([doc](docs/modules/ROOT/pages/node_pattern.adoc))
 
 This gem may be used independently from the main RuboCop gem. It was extracted from RuboCop in version 0.84 and its only
-dependency is the `parser` gem, which `rubocop-ast` extends.
+dependency is the [parser](https://github.com/whitequark/parser) gem, which `rubocop-ast` extends.
 
 ## Installation
 
@@ -28,7 +29,9 @@ gem 'rubocop-ast'
 
 ## Usage
 
-Refer to the documentation of `RuboCop::AST::Node` and [`RuboCop::AST::NodePattern`](docs/modules/ROOT/pages/node_pattern.adoc)
+Refer to the documentation of [`RuboCop::AST::Node`](docs/modules/ROOT/pages/node_types.adoc) and [`RuboCop::AST::NodePattern`](docs/modules/ROOT/pages/node_pattern.adoc)
+
+See the [docs site](https://docs.rubocop.org/rubocop-ast) for more details.
 
 ### Parser compatibility switches
 

data/lib/rubocop/ast/node.rb

@@ -313,8 +313,8 @@ module RuboCop
       def_node_matcher :defined_module0, <<~PATTERN
         {(class (const $_ $_) ...)
          (module (const $_ $_) ...)
-         (casgn $_ $_        (send (const nil? {:Class :Module}) :new ...))
-         (casgn $_ $_ (block (send (const nil? {:Class :Module}) :new ...) ...))}
+         (casgn $_ $_        (send #global_const?({:Class :Module}) :new ...))
+         (casgn $_ $_ (block (send #global_const?({:Class :Module}) :new ...) ...))}
       PATTERN
 
       private :defined_module0
@@ -496,16 +496,33 @@ module RuboCop
 
       def_node_matcher :proc?, <<~PATTERN
         {(block (send nil? :proc) ...)
-         (block (send (const nil? :Proc) :new) ...)
-         (send (const nil? :Proc) :new)}
+         (block (send #global_const?(:Proc) :new) ...)
+         (send #global_const?(:Proc) :new)}
       PATTERN
 
       def_node_matcher :lambda?, '({block numblock} (send nil? :lambda) ...)'
       def_node_matcher :lambda_or_proc?, '{lambda? proc?}'
 
+      def_node_matcher :global_const?, '(const {nil? cbase} %1)'
+
       def_node_matcher :class_constructor?, <<~PATTERN
-        {       (send (const nil? {:Class :Module}) :new ...)
-         (block (send (const nil? {:Class :Module}) :new ...) ...)}
+        {       (send #global_const?({:Class :Module}) :new ...)
+         (block (send #global_const?({:Class :Module}) :new ...) ...)}
+      PATTERN
+
+      def_node_matcher :struct_constructor?, <<~PATTERN
+        (block (send #global_const?(:Struct) :new ...) _ $_)
+      PATTERN
+
+      def_node_matcher :class_definition?, <<~PATTERN
+        {(class _ _ $_)
+         (sclass _ $_)
+         (block (send #global_const?({:Struct :Class}) :new ...) _ $_)}
+      PATTERN
+
+      def_node_matcher :module_definition?, <<~PATTERN
+        {(module _ $_)
+         (block (send #global_const?(:Module) :new ...) _ $_)}
       PATTERN
 
       # Some expressions are evaluated for their value, some for their side

data/lib/rubocop/ast/node/array_node.rb

@@ -14,15 +14,9 @@ module RuboCop
       # Returns an array of all value nodes in the `array` literal.
       #
       # @return [Array<Node>] an array of value nodes
-      def values
-        each_child_node.to_a
-      end
+      alias values children
 
-      # Calls the given block for all values in the `array` literal.
-      #
-      # @yieldparam [Node] node each node
-      # @return [self] if a block is given
-      # @return [Enumerator] if no block is given
+      # @deprecated Use `values.each` (a.k.a. `children.each`)
       def each_value(&block)
         return to_enum(__method__) unless block_given?
 

data/lib/rubocop/ast/node/case_match_node.rb

@@ -15,11 +15,7 @@ module RuboCop
         'case'
       end
 
-      # Calls the given block for each `in_pattern` node in the `in` statement.
-      # If no block is given, an `Enumerator` is returned.
-      #
-      # @return [self] if a block is given
-      # @return [Enumerator] if no block is given
+      # @deprecated Use `in_pattern_branches.each`
       def each_in_pattern
         return in_pattern_branches.to_enum(__method__) unless block_given?
 

data/lib/rubocop/ast/node/case_node.rb

@@ -15,11 +15,7 @@ module RuboCop
         'case'
       end
 
-      # Calls the given block for each `when` node in the `case` statement.
-      # If no block is given, an `Enumerator` is returned.
-      #
-      # @return [self] if a block is given
-      # @return [Enumerator] if no block is given
+      # @deprecated Use `when_branches.each`
       def each_when
         return when_branches.to_enum(__method__) unless block_given?
 

data/lib/rubocop/ast/node/def_node.rb

@@ -31,14 +31,14 @@ module RuboCop
       #
       # @return [Symbol] the name of the defined method
       def method_name
-        node_parts[2]
+        children[-3]
       end
 
       # An array containing the arguments of the method definition.
       #
       # @return [Array<Node>] the arguments of the method definition
       def arguments
-        node_parts[1]
+        children[-2]
       end
 
       # The body of the method definition.
@@ -49,33 +49,14 @@ module RuboCop
       #
       # @return [Node] the body of the method definition
       def body
-        node_parts[0]
+        children[-1]
       end
 
       # The receiver of the method definition, if any.
       #
       # @return [Node, nil] the receiver of the method definition, or `nil`.
       def receiver
-        node_parts[3]
-      end
-
-      # Custom destructuring method. This can be used to normalize
-      # destructuring for different variations of the node.
-      #
-      # In this case, the `def` node destructures into:
-      #
-      #   `method_name, arguments, body`
-      #
-      # while the `defs` node destructures into:
-      #
-      #   `receiver, method_name, arguments, body`
-      #
-      # so we reverse the destructured array to get the optional receiver
-      # at the end, where it can be discarded.
-      #
-      # @return [Array] the different parts of the `def` or `defs` node
-      def node_parts
-        to_a.reverse
+        children[-4]
       end
     end
   end

data/lib/rubocop/ast/node/hash_node.rb

@@ -8,6 +8,9 @@ module RuboCop
     class HashNode < Node
       # Returns an array of all the key value pairs in the `hash` literal.
       #
+      # @note this may be different from children as `kwsplat` nodes are
+      # ignored.
+      #
       # @return [Array<PairNode>] an array of `pair` nodes
       def pairs
         each_pair.to_a
@@ -23,6 +26,8 @@ module RuboCop
       # Calls the given block for each `pair` node in the `hash` literal.
       # If no block is given, an `Enumerator` is returned.
       #
+      # @note `kwsplat` nodes are ignored.
+      #
       # @return [self] if a block is given
       # @return [Enumerator] if no block is given
       def each_pair
@@ -37,6 +42,8 @@ module RuboCop
 
       # Returns an array of all the keys in the `hash` literal.
       #
+      # @note `kwsplat` nodes are ignored.
+      #
       # @return [Array<Node>] an array of keys in the `hash` literal
       def keys
         each_key.to_a
@@ -45,6 +52,8 @@ module RuboCop
       # Calls the given block for each `key` node in the `hash` literal.
       # If no block is given, an `Enumerator` is returned.
       #
+      # @note `kwsplat` nodes are ignored.
+      #
       # @return [self] if a block is given
       # @return [Enumerator] if no block is given
       def each_key
@@ -59,6 +68,8 @@ module RuboCop
 
       # Returns an array of all the values in the `hash` literal.
       #
+      # @note `kwsplat` nodes are ignored.
+      #
       # @return [Array<Node>] an array of values in the `hash` literal
       def values
         each_pair.map(&:value)
@@ -67,6 +78,8 @@ module RuboCop
       # Calls the given block for each `value` node in the `hash` literal.
       # If no block is given, an `Enumerator` is returned.
       #
+      # @note `kwsplat` nodes are ignored.
+      #
       # @return [self] if a block is given
       # @return [Enumerator] if no block is given
       def each_value
@@ -85,6 +98,8 @@ module RuboCop
       # @note A multiline `pair` is considered to be on the same line if it
       #       shares any of its lines with another `pair`
       #
+      # @note `kwsplat` nodes are ignored.
+      #
       # @return [Boolean] whether any `pair` nodes are on the same line
       def pairs_on_same_line?
         pairs.each_cons(2).any? { |first, second| first.same_line?(second) }
@@ -93,6 +108,8 @@ module RuboCop
       # Checks whether this `hash` uses a mix of hash rocket and colon
       # delimiters for its pairs.
       #
+      # @note `kwsplat` nodes are ignored.
+      #
       # @return [Boolean] whether the `hash` uses mixed delimiters
       def mixed_delimiters?
         pairs.map(&:delimiter).uniq.size > 1

data/lib/rubocop/ast/node/if_node.rb

@@ -64,10 +64,9 @@ module RuboCop
       #
       # @return [String] the inverse keyword of the `if` statement
       def inverse_keyword
-        if keyword == 'if'
-          'unless'
-        elsif keyword == 'unless'
-          'if'
+        case keyword
+        when 'if' then 'unless'
+        when 'unless' then 'if'
         else
           ''
         end
@@ -158,11 +157,7 @@ module RuboCop
         branches.concat(other_branches)
       end
 
-      # Calls the given block for each branch node in the conditional statement.
-      # If no block is given, an `Enumerator` is returned.
-      #
-      # @return [self] if a block is given
-      # @return [Enumerator] if no block is given
+      # @deprecated Use `branches.each`
       def each_branch
         return branches.to_enum(__method__) unless block_given?
 

data/lib/rubocop/ast/node/when_node.rb

@@ -13,11 +13,7 @@ module RuboCop
         node_parts[0...-1]
       end
 
-      # Calls the given block for each condition node in the `when` branch.
-      # If no block is given, an `Enumerator` is returned.
-      #
-      # @return [self] if a block is given
-      # @return [Enumerator] if no block is given
+      # @deprecated Use `conditions.each`
       def each_condition
         return conditions.to_enum(__method__) unless block_given?
 

data/lib/rubocop/ast/node_pattern.rb

@@ -84,7 +84,7 @@ module RuboCop
     #                         # matching process starts
     #     '(send _ %named)'   # arguments can also be passed as named
     #                         # parameters (see `%1`)
-    #                         # Note that the macros `def_node_pattern` and
+    #                         # Note that the macros `def_node_matcher` and
     #                         # `def_node_search` accept default values for these.
     #     '(send _ %CONST)'   # the named constant will act like `%1` and `%named`.
     #     '^^send'            # each ^ ascends one level in the AST
@@ -96,6 +96,9 @@ module RuboCop
     #                         # 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
+    #                         # These arguments can be patterns themselves, in
+    #                         # which case a matcher responding to === will be
+    #                         # passed.
     #
     # You can nest arbitrarily deep:
     #
@@ -110,11 +113,6 @@ module RuboCop
     # and so on. Therefore, if you add methods which are named like
     # `#prefix_type?` to the AST node class, then 'prefix' will become usable as
     # a pattern.
-    #
-    # Also note that if you need a "guard clause" to protect against possible nils
-    # in a certain place in the AST, you can do it like this: `[!nil <pattern>]`
-    #
-    # The compiler code is very simple; don't be afraid to read through it!
     class NodePattern
       # @private
       Invalid = Class.new(StandardError)
@@ -135,8 +133,10 @@ module RuboCop
         PARAM_NUMBER = /%\d*/.freeze
 
         SEPARATORS = /\s+/.freeze
-        TOKENS     = Regexp.union(META, PARAM_CONST, KEYWORD_NAME, PARAM_NUMBER, NUMBER,
-                                  METHOD_NAME, SYMBOL, STRING)
+        ONLY_SEPARATOR = /\A#{SEPARATORS}\Z/.freeze
+
+        TOKENS = Regexp.union(META, PARAM_CONST, KEYWORD_NAME, PARAM_NUMBER, NUMBER,
+                              METHOD_NAME, SYMBOL, STRING)
 
         TOKEN = /\G(?:#{SEPARATORS}|#{TOKENS}|.)/.freeze
 
@@ -163,6 +163,7 @@ module RuboCop
         CUR_NODE = "#{CUR_PLACEHOLDER} node@@@"
         CUR_ELEMENT = "#{CUR_PLACEHOLDER} element@@@"
         SEQ_HEAD_GUARD = '@@@seq guard head@@@'
+        MULTIPLE_CUR_PLACEHOLDER = /#{CUR_PLACEHOLDER}.*#{CUR_PLACEHOLDER}/.freeze
 
         line = __LINE__
         ANY_ORDER_TEMPLATE = ERB.new <<~RUBY.gsub("-%>\n", '%>')
@@ -199,22 +200,26 @@ module RuboCop
         RUBY
         REPEATED_TEMPLATE.location = [__FILE__, line + 1]
 
-        def initialize(str, node_var = 'node0')
+        def initialize(str, root = 'node0', node_var = root)
           @string   = str
-          @root     = node_var
+          # For def_node_pattern, root == node_var
+          # For def_node_search, root is the root node to search on,
+          # and node_var is the current descendant being searched.
+          @root     = root
+          @node_var = node_var
 
           @temps    = 0  # avoid name clashes between temp variables
           @captures = 0  # number of captures seen
           @unify    = {} # named wildcard -> temp variable
           @params   = 0  # highest % (param) number seen
           @keywords = Set[] # keyword parameters seen
-          run(node_var)
+          run
         end
 
-        def run(node_var)
+        def run
           @tokens = Compiler.tokens(@string)
 
-          @match_code = with_context(compile_expr, node_var, use_temp_node: false)
+          @match_code = with_context(compile_expr, @node_var, use_temp_node: false)
           @match_code.prepend("(captures = Array.new(#{@captures})) && ") \
             if @captures.positive?
 
@@ -234,6 +239,10 @@ module RuboCop
           #   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 ...")
+          if (atom = compile_atom(token))
+            return atom_to_expr(atom)
+          end
+
           case token
           when '('       then compile_seq
           when '{'       then compile_union
@@ -242,16 +251,10 @@ module RuboCop
           when '$'       then compile_capture
           when '^'       then compile_ascend
           when '`'       then compile_descend
-          when WILDCARD  then compile_wildcard(token[1..-1])
+          when WILDCARD  then compile_new_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 KEYWORD   then compile_keyword(token[1..-1])
-          when CONST     then compile_const(token[1..-1])
-          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}")
           end
         end
@@ -260,7 +263,7 @@ module RuboCop
         def tokens_until(stop, what)
           return to_enum __method__, stop, what unless block_given?
 
-          fail_due_to("empty #{what}") if tokens.first == stop && what
+          fail_due_to("empty #{what}") if tokens.first == stop
           yield until tokens.first == stop
           tokens.shift
         end
@@ -324,11 +327,15 @@ module RuboCop
         # @private
         # Builds Ruby code for a sequence
         # (head *first_terms variadic_term *last_terms)
-        class Sequence < SimpleDelegator
+        class Sequence
+          extend Forwardable
+          def_delegators :@compiler, :compile_guard_clause, :with_seq_head_context,
+                         :with_child_context, :fail_due_to
+
           def initialize(compiler, *arity_term_list)
             @arities, @terms = arity_term_list.transpose
 
-            super(compiler)
+            @compiler = 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) }
@@ -581,29 +588,18 @@ module RuboCop
           end
         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_ELEMENT} == #{access_unify(name)}"
-          else
-            n = @unify[name] = "unify_#{name.gsub('-', '__')}"
-            # double assign to avoid "assigned but unused variable"
-            "(#{n} = #{CUR_ELEMENT}; " \
-            "#{n} = #{n}; true)"
-          end
-        end
+        # Known wildcards are considered atoms, see `compile_atom`
+        def compile_new_wildcard(name)
+          return 'true' if name.empty?
 
-        def compile_literal(literal)
-          "#{CUR_ELEMENT} == #{literal}"
+          n = @unify[name] = "unify_#{name.gsub('-', '__')}"
+          # double assign to avoid "assigned but unused variable"
+          "(#{n} = #{CUR_ELEMENT}; #{n} = #{n}; true)"
         end
 
         def compile_predicate(predicate)
           if predicate.end_with?('(') # is there an arglist?
-            args = compile_args(tokens)
+            args = compile_args
             predicate = predicate[0..-2] # drop the trailing (
             "#{CUR_ELEMENT}.#{predicate}(#{args.join(',')})"
           else
@@ -616,7 +612,7 @@ module RuboCop
           # 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)
+            args = compile_args
             method = method[0..-2] # drop the trailing (
             "#{method}(#{CUR_ELEMENT},#{args.join(',')})"
           else
@@ -628,43 +624,44 @@ module RuboCop
           "#{compile_guard_clause} && #{CUR_NODE}.#{type.tr('-', '_')}_type?"
         end
 
-        def compile_param(number)
-          "#{get_param(number)} === #{CUR_ELEMENT}"
-        end
-
-        def compile_const(const)
-          "#{get_const(const)} === #{CUR_ELEMENT}"
+        def compile_args
+          tokens_until(')', 'call arguments').map do
+            arg = compile_arg
+            tokens.shift if tokens.first == ','
+            arg
+          end
         end
 
-        def compile_keyword(keyword)
-          "#{get_keyword(keyword)} === #{CUR_ELEMENT}"
+        def atom_to_expr(atom)
+          "#{atom} === #{CUR_ELEMENT}"
         end
 
-        def compile_args(tokens)
-          index = tokens.find_index { |token| token == ')' }
-
-          tokens.slice!(0..index).each_with_object([]) do |token, args|
-            next if [')', ','].include?(token)
-
-            args << compile_arg(token)
+        def expr_to_atom(expr)
+          with_temp_variables do |compare|
+            in_context = with_context(expr, compare, use_temp_node: false)
+            "::RuboCop::AST::NodePattern::Matcher.new{|#{compare}| #{in_context}}"
           end
         end
 
-        def compile_arg(token)
-          name = token[1..-1]
+        # @return compiled atom (e.g. ":literal" or "SOME_CONST")
+        #         or nil if not a simple atom (unknown wildcard, other tokens)
+        def compile_atom(token)
           case token
-          when WILDCARD
-            access_unify(name) || fail_due_to('invalid in arglist: ' + token)
+          when WILDCARD  then access_unify(token[1..-1]) # could be nil
           when LITERAL   then token
-          when KEYWORD   then get_keyword(name)
-          when CONST     then get_const(name)
-          when PARAM     then get_param(name)
+          when KEYWORD   then get_keyword(token[1..-1])
+          when CONST     then get_const(token[1..-1])
+          when PARAM     then get_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 in arglist: #{token.inspect}")
           end
         end
 
+        def compile_arg
+          token = tokens.shift
+          compile_atom(token) || expr_to_atom(compile_expr(token))
+        end
+
         def next_capture
           index = @captures
           @captures += 1
@@ -716,10 +713,10 @@ module RuboCop
           @keywords.map { |k| format(pattern, keyword: k) }.join(',')
         end
 
-        def emit_trailing_params(forwarding: false)
+        def emit_params(*first, forwarding: false)
           params = emit_param_list
           keywords = emit_keyword_list(forwarding: forwarding)
-          [params, keywords].reject(&:empty?).map { |p| ", #{p}" }.join
+          [*first, params, keywords].reject(&:empty?).join(',')
         end
 
         def emit_method_code
@@ -754,7 +751,7 @@ module RuboCop
         end
 
         def auto_use_temp_node?(code)
-          code.scan(CUR_PLACEHOLDER).count > 1
+          code.match?(MULTIPLE_CUR_PLACEHOLDER)
         end
 
         # with_<...>_context methods are used whenever the context,
@@ -793,16 +790,22 @@ module RuboCop
         end
 
         def self.tokens(pattern)
-          pattern.scan(TOKEN).reject { |token| token =~ /\A#{SEPARATORS}\Z/ }
+          pattern.scan(TOKEN).grep_v(ONLY_SEPARATOR)
+        end
+
+        # This method minimizes the closure for our method
+        def wrapping_block(method_name, **defaults)
+          proc do |*args, **values|
+            send method_name, *args, **defaults, **values
+          end
         end
 
         def def_helper(base, method_name, **defaults)
           location = caller_locations(3, 1).first
           unless defaults.empty?
-            base.send :define_method, method_name do |*args, **values|
-              send method_name, *args, **defaults, **values
-            end
-            method_name = :"without_defaults_#{method_name}"
+            call = :"without_defaults_#{method_name}"
+            base.send :define_method, method_name, &wrapping_block(call, **defaults)
+            method_name = call
           end
           src = yield method_name
           base.class_eval(src, location.path, location.lineno)
@@ -811,7 +814,7 @@ module RuboCop
         def def_node_matcher(base, method_name, **defaults)
           def_helper(base, method_name, **defaults) do |name|
             <<~RUBY
-              def #{name}(node = self#{emit_trailing_params})
+              def #{name}(#{emit_params('node = self')})
                 #{emit_method_code}
               end
             RUBY
@@ -828,20 +831,18 @@ module RuboCop
           if method_name.to_s.end_with?('?')
             on_match = 'return true'
           else
-            prelude = <<~RUBY
-              return enum_for(:#{method_name},
-                node0#{emit_trailing_params(forwarding: true)}) unless block_given?
-            RUBY
-            on_match = emit_yield_capture('node')
+            args = emit_params(":#{method_name}", @root, forwarding: true)
+            prelude = "return enum_for(#{args}) unless block_given?\n"
+            on_match = emit_yield_capture(@node_var)
           end
           emit_node_search_body(method_name, prelude: prelude, on_match: on_match)
         end
 
         def emit_node_search_body(method_name, prelude:, on_match:)
           <<~RUBY
-            def #{method_name}(node0#{emit_trailing_params})
+            def #{method_name}(#{emit_params(@root)})
               #{prelude}
-              node0.each_node do |node|
+              #{@root}.each_node do |#{@node_var}|
                 if #{match_code}
                   #{on_match}
                 end
@@ -874,7 +875,7 @@ 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, **keyword_defaults)
-          Compiler.new(pattern_str, 'node')
+          Compiler.new(pattern_str, 'node0', 'node')
                   .def_node_search(self, method_name, **keyword_defaults)
         end
       end
@@ -883,8 +884,8 @@ module RuboCop
 
       def initialize(str)
         @pattern = str
-        compiler = Compiler.new(str)
-        src = "def match(node0#{compiler.emit_trailing_params});" \
+        compiler = Compiler.new(str, 'node0')
+        src = "def match(#{compiler.emit_params('node0')});" \
               "#{compiler.emit_method_code}end"
         instance_eval(src, __FILE__, __LINE__ + 1)
       end
@@ -933,6 +934,17 @@ module RuboCop
 
         nil
       end
+
+      # @api private
+      class Matcher
+        def initialize(&block)
+          @block = block
+        end
+
+        def ===(compare)
+          @block.call(compare)
+        end
+      end
     end
   end
 end

data/lib/rubocop/ast/processed_source.rb

@@ -71,18 +71,22 @@ module RuboCop
         Digest::SHA1.hexdigest(@raw_source)
       end
 
+      # @deprecated Use `comments.each`
       def each_comment
         comments.each { |comment| yield comment }
       end
 
+      # @deprecated Use `comments.find`
       def find_comment
         comments.find { |comment| yield comment }
       end
 
+      # @deprecated Use `tokens.each`
       def each_token
         tokens.each { |token| yield token }
       end
 
+      # @deprecated Use `tokens.find`
       def find_token
         tokens.find { |token| yield token }
       end
@@ -95,10 +99,20 @@ module RuboCop
         ast.nil?
       end
 
-      def commented?(source_range)
-        comment_lines.include?(source_range.line)
+      # @return [Boolean] if the given line number has a comment.
+      def line_with_comment?(line)
+        comment_lines.include?(line)
       end
 
+      # @return [Boolean] if any of the lines in the given `source_range` has a comment.
+      def contains_comment?(source_range)
+        (source_range.line..source_range.last_line).any? do |line|
+          line_with_comment?(line)
+        end
+      end
+      # @deprecated use contains_comment?
+      alias commented? contains_comment?
+
       def comments_before_line(line)
         comments.select { |c| c.location.line <= line }
       end

data/lib/rubocop/ast/traversal.rb

@@ -34,7 +34,7 @@ module RuboCop
                              match_with_lvasgn begin kwbegin return
                              in_match match_alt
                              match_as array_pattern array_pattern_with_tail
-                             hash_pattern const_pattern
+                             hash_pattern const_pattern find_pattern
                              index indexasgn].freeze
       SECOND_CHILD_ONLY = %i[lvasgn ivasgn cvasgn gvasgn optarg kwarg
                              kwoptarg].freeze

data/lib/rubocop/ast/version.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module AST
     module Version
-      STRING = '0.1.0'
+      STRING = '0.2.0'
     end
   end
 end

metadata

@@ -1,16 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-ast
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Bozhidar Batsov
 - Jonas Arvidsson
 - Yuji Nakayama
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-26 00:00:00.000000000 Z
+date: 2020-07-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -125,7 +125,7 @@ metadata:
   source_code_uri: https://github.com/rubocop-hq/rubocop-ast/
   documentation_uri: https://docs.rubocop.org/rubocop-ast/
   bug_tracker_uri: https://github.com/rubocop-hq/rubocop-ast/issues
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -141,7 +141,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.2
-signing_key: 
+signing_key:
 specification_version: 4
 summary: RuboCop tools to deal with Ruby code AST.
 test_files: []