rubocop-ast 0.1.0 → 0.4.2

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

@@ -6,13 +6,19 @@ module RuboCop
     # node when the builder constructs the AST, making its methods available
     # to all `send` nodes within RuboCop.
     class SendNode < Node
-      include ParameterizedNode
+      include ParameterizedNode::RestArguments
       include MethodDispatchNode
 
       def_node_matcher :attribute_accessor?, <<~PATTERN
         [(send nil? ${:attr_reader :attr_writer :attr_accessor :attr} $...)
          (_    _    _                                                 _ ...)]
       PATTERN
+
+      private
+
+      def first_argument_index
+        2
+      end
     end
   end
 end

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

@@ -16,6 +16,8 @@ module RuboCop
       def node_parts
         [nil, :super, *to_a]
       end
+
+      alias arguments children
     end
   end
 end

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

@@ -13,17 +13,11 @@ 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
-      def each_condition
+      # @deprecated Use `conditions.each`
+      def each_condition(&block)
         return conditions.to_enum(__method__) unless block_given?
 
-        conditions.each do |condition|
-          yield condition
-        end
+        conditions.each(&block)
 
         self
       end

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

@@ -16,6 +16,8 @@ module RuboCop
       def node_parts
         [nil, :yield, *to_a]
       end
+
+      alias arguments children
     end
   end
 end

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,10 @@ 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.
+    #     '# comment'         # comments are accepted at the end of lines
     #
     # You can nest arbitrarily deep:
     #
@@ -110,11 +114,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)
@@ -124,6 +123,8 @@ module RuboCop
       class Compiler
         SYMBOL       = %r{:(?:[\w+@*/?!<>=~|%^-]+|\[\]=?)}.freeze
         IDENTIFIER   = /[a-zA-Z_][a-zA-Z0-9_-]*/.freeze
+        COMMENT      = /#\s.*$/.freeze
+
         META         = Regexp.union(
           %w"( ) { } [ ] $< < > $... $ ! ^ ` ... + * ?"
         ).freeze
@@ -135,8 +136,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 +166,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 +203,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_matcher, 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 +242,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 +254,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 +266,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 +330,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) }
@@ -448,7 +458,6 @@ module RuboCop
           [0..Float::INFINITY, 'true']
         end
 
-        # rubocop:disable Metrics/AbcSize
         # rubocop:disable Metrics/MethodLength
         def compile_any_order(capture_all = nil)
           rest = capture_rest = nil
@@ -468,7 +477,6 @@ module RuboCop
           end
         end
         # rubocop:enable Metrics/MethodLength
-        # rubocop:enable Metrics/AbcSize
 
         def insure_same_captures(enum, what)
           return to_enum __method__, enum, what unless block_given?
@@ -581,29 +589,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 +613,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 +625,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 +714,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 +752,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 +791,22 @@ module RuboCop
         end
 
         def self.tokens(pattern)
-          pattern.scan(TOKEN).reject { |token| token =~ /\A#{SEPARATORS}\Z/ }
+          pattern.gsub(COMMENT, '').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 +815,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 +832,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 +876,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 +885,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 +935,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