rubocop-ast 0.0.3 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b0c196be6c58699fcb84209860508c96e69e8122adb8e14d6641134009802712
-  data.tar.gz: a2d50c781f612349b4aa7e24a4ea4008c359ce766a6f5e0f7e925ac78d57dbb7
+  metadata.gz: 4108494066548a429e972d3f2afcaa9adfd39072a929308cdb20e4a602fef66d
+  data.tar.gz: 413b4382539bffed1760d0599bc093ad40ffef64992f821484994150903812da
 SHA512:
-  metadata.gz: 2d263c6a0ab978cb1b81dde253ce752c2b64af9e94c59ac6a6a364aef3cec37c03028e4d7c00086c11b8b46abae9373edad636528782f84ad914ea527b644ec0
-  data.tar.gz: edeefb4a74f678920907e130ea6a7fea86b4c67cf9a9bbaefa21ef231738c0de541d61de5d9c234384e46b3243a74ffaac84288b2c68c49e3178cb39d2d96b37
+  metadata.gz: 97af9dd864e8f6867614a79b2aac596e18e147b9a55bcc67b8755e47ef762730ec69612dcc6858ee12017b33beae0b89e008e1267034f1730682015c4efa4255
+  data.tar.gz: 807305ab6dc90885fff96d1387d787debf8ce8f27a0d150ad4bf86a76d4afb2d288f0771b2399cf3c3cfb1472c72cd750e4df9e97ad07467da4615a97c062f79

data/README.md

@@ -2,12 +2,15 @@
 
 [![Gem Version](https://badge.fury.io/rb/rubocop-ast.svg)](https://badge.fury.io/rb/rubocop-ast)
 [![CI](https://github.com/rubocop-hq/rubocop-ast/workflows/CI/badge.svg)](https://github.com/rubocop-hq/rubocop-ast/actions?query=workflow%3ACI)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/a29666e6373bc41bc0a9/test_coverage)](https://codeclimate.com/github/rubocop-hq/rubocop-ast/test_coverage)
+[![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::NodePattern` ([doc](manual/node_pattern.md))
+* `RuboCop::AST::NodePattern` ([doc](docs/modules/ROOT/pages/node_pattern.adoc))
 
-This gem may be used independently from the main RuboCop gem.
+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.
 
 ## Installation
 
@@ -25,7 +28,17 @@ gem 'rubocop-ast'
 
 ## Usage
 
-Refer to the documentation of `RuboCop::AST::Node` and [`RuboCop::AST::NodePattern`](manual/node_pattern.md)
+Refer to the documentation of `RuboCop::AST::Node` and [`RuboCop::AST::NodePattern`](docs/modules/ROOT/pages/node_pattern.adoc)
+
+### Parser compatibility switches
+
+The main `RuboCop` gem uses [legacy AST output from parser](https://github.com/whitequark/parser/#usage).
+This gem is meant to be compatible with all settings. For example, to have `-> { ... }` emitted
+as `LambdaNode` instead of `SendNode`:
+
+```ruby
+RuboCop::AST::Builder.emit_lambda = true
+```
 
 ## Contributing
 

data/lib/rubocop/ast.rb

@@ -2,6 +2,7 @@
 
 require 'parser'
 require 'forwardable'
+require 'set'
 
 require_relative 'ast/node_pattern'
 require_relative 'ast/sexp'
@@ -34,8 +35,11 @@ require_relative 'ast/node/forward_args_node'
 require_relative 'ast/node/float_node'
 require_relative 'ast/node/hash_node'
 require_relative 'ast/node/if_node'
+require_relative 'ast/node/index_node'
+require_relative 'ast/node/indexasgn_node'
 require_relative 'ast/node/int_node'
 require_relative 'ast/node/keyword_splat_node'
+require_relative 'ast/node/lambda_node'
 require_relative 'ast/node/module_node'
 require_relative 'ast/node/or_node'
 require_relative 'ast/node/pair_node'

data/lib/rubocop/ast/builder.rb

@@ -35,9 +35,12 @@ module RuboCop
         hash:         HashNode,
         if:           IfNode,
         int:          IntNode,
+        index:        IndexNode,
+        indexasgn:    IndexasgnNode,
         irange:       RangeNode,
         erange:       RangeNode,
         kwsplat:      KeywordSplatNode,
+        lambda:       LambdaNode,
         module:       ModuleNode,
         or:           OrNode,
         pair:         PairNode,

data/lib/rubocop/ast/node.rb

@@ -44,6 +44,8 @@ module RuboCop
 
       BASIC_CONDITIONALS = %i[if while until].freeze
       CONDITIONALS = [*BASIC_CONDITIONALS, :case].freeze
+      POST_CONDITION_LOOP_TYPES = %i[while_post until_post].freeze
+      LOOP_TYPES = (POST_CONDITION_LOOP_TYPES + %i[while until for]).freeze
       VARIABLES = %i[ivar gvar cvar lvar].freeze
       REFERENCES = %i[nth_ref back_ref].freeze
       KEYWORDS = %i[alias and break case class def defs defined?
@@ -53,6 +55,7 @@ module RuboCop
                     yield].freeze
       OPERATOR_KEYWORDS = %i[and or].freeze
       SPECIAL_KEYWORDS = %w[__FILE__ __LINE__ __ENCODING__].freeze
+      ARGUMENT_TYPES = %i[arg optarg restarg kwarg kwoptarg kwrestarg blockarg].freeze
 
       # @see https://www.rubydoc.info/gems/ast/AST/Node:initialize
       def initialize(type, children = [], properties = {})
@@ -425,6 +428,15 @@ module RuboCop
         CONDITIONALS.include?(type)
       end
 
+      def post_condition_loop?
+        POST_CONDITION_LOOP_TYPES.include?(type)
+      end
+
+      # Note: `loop { }` is a normal method call and thus not a loop keyword.
+      def loop_keyword?
+        LOOP_TYPES.include?(type)
+      end
+
       def keyword?
         return true if special_keyword? || send_type? && prefix_not?
         return false unless KEYWORDS.include?(type)
@@ -456,6 +468,10 @@ module RuboCop
         parent&.send_type? && parent.arguments.include?(self)
       end
 
+      def argument_type?
+        ARGUMENT_TYPES.include?(type)
+      end
+
       def boolean_type?
         true_type? || false_type?
       end
@@ -500,7 +516,7 @@ module RuboCop
       # So, does the return value of this node matter? If we changed it to
       # `(...; nil)`, might that affect anything?
       #
-      # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/MethodLength
       def value_used?
         # Be conservative and return true if we're not sure.
         return false if parent.nil?
@@ -522,7 +538,7 @@ module RuboCop
           true
         end
       end
-      # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
+      # rubocop:enable Metrics/MethodLength
 
       # Some expressions are evaluated for their value, some for their side
       # effects, and some for both.

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

@@ -24,7 +24,7 @@ module RuboCop
       #
       # @return [Boolean] whether the `def` node uses argument forwarding
       def argument_forwarding?
-        arguments.any?(&:forward_args_type?)
+        arguments.any?(&:forward_args_type?) || arguments.any?(&:forward_arg_type?)
       end
 
       # The name of the defined method as a symbol.

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

@@ -5,6 +5,21 @@ module RuboCop
     # A node extension for `forward-args` nodes. This will be used in place
     # of a plain node when the builder constructs the AST, making its methods
     # available to all `forward-args` nodes within RuboCop.
+    #
+    # Not used with modern emitters:
+    #
+    #   $ ruby-parse -e "def foo(...); end"
+    #   (def :foo
+    #     (args
+    #       (forward-arg)) nil)
+    #   $ ruby-parse --legacy -e "->(foo) { bar }"
+    #   (def :foo
+    #     (forward-args) nil)
+    #
+    # Note the extra 's' with legacy form.
+    #
+    # The main RuboCop runs in legacy mode; this node is only used
+    # if user `AST::Builder.modernize` or `AST::Builder.emit_lambda=true`
     class ForwardArgsNode < Node
       include CollectionNode
 

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Used for modern support only!
+    # Not as thoroughly tested as legacy equivalent
+    #
+    #   $ ruby-parse -e "foo[:bar]"
+    #   (index
+    #     (send nil :foo)
+    #     (sym :bar))
+    #   $ ruby-parse --legacy -e "foo[:bar]"
+    #   (send
+    #     (send nil :foo) :[]
+    #     (sym :bar))
+    #
+    # The main RuboCop runs in legacy mode; this node is only used
+    # if user `AST::Builder.modernize` or `AST::Builder.emit_index=true`
+    class IndexNode < Node
+      include ParameterizedNode
+      include MethodDispatchNode
+
+      # For similarity with legacy mode
+      def attribute_accessor?
+        false
+      end
+
+      # For similarity with legacy mode
+      def assignment_method?
+        false
+      end
+
+      # For similarity with legacy mode
+      def method_name
+        :[]
+      end
+
+      # An array containing the arguments of the dispatched method.
+      #
+      # @return [Array<Node>] the arguments of the dispatched method
+      def arguments
+        node_parts[1..-1]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Used for modern support only!
+    # Not as thoroughly tested as legacy equivalent
+    #
+    #   $ ruby-parse -e "foo[:bar] = :baz"
+    #   (indexasgn
+    #     (send nil :foo)
+    #     (sym :bar)
+    #     (sym :baz))
+    #   $ ruby-parse --legacy -e "foo[:bar] = :baz"
+    #   (send
+    #     (send nil :foo) :[]=
+    #     (sym :bar)
+    #     (sym :baz))
+    #
+    # The main RuboCop runs in legacy mode; this node is only used
+    # if user `AST::Builder.modernize` or `AST::Builder.emit_index=true`
+    class IndexasgnNode < Node
+      include ParameterizedNode
+      include MethodDispatchNode
+
+      # For similarity with legacy mode
+      def attribute_accessor?
+        false
+      end
+
+      # For similarity with legacy mode
+      def assignment_method?
+        true
+      end
+
+      # For similarity with legacy mode
+      def method_name
+        :[]=
+      end
+
+      # An array containing the arguments of the dispatched method.
+      #
+      # @return [Array<Node>] the arguments of the dispatched method
+      def arguments
+        node_parts[1..-1]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # Used for modern support only:
+    # Not as thoroughly tested as legacy equivalent
+    #
+    #   $ ruby-parse -e "->(foo) { bar }"
+    #   (block
+    #     (lambda)
+    #     (args
+    #       (arg :foo))
+    #     (send nil :bar))
+    #   $ ruby-parse --legacy -e "->(foo) { bar }"
+    #   (block
+    #     (send nil :lambda)
+    #     (args
+    #       (arg :foo))
+    #     (send nil :bar))
+    #
+    # The main RuboCop runs in legacy mode; this node is only used
+    # if user `AST::Builder.modernize` or `AST::Builder.emit_lambda=true`
+    class LambdaNode < Node
+      include ParameterizedNode
+      include MethodDispatchNode
+
+      # For similarity with legacy mode
+      def lambda?
+        true
+      end
+
+      # For similarity with legacy mode
+      def lambda_literal?
+        true
+      end
+
+      # For similarity with legacy mode
+      def attribute_accessor?
+        false
+      end
+
+      # For similarity with legacy mode
+      def assignment_method?
+        false
+      end
+
+      # For similarity with legacy mode
+      def method_name
+        :lambda
+      end
+
+      # For similarity with legacy mode
+      def arguments
+        []
+      end
+    end
+  end
+end

data/lib/rubocop/ast/node/mixin/method_dispatch_node.rb

@@ -3,7 +3,8 @@
 module RuboCop
   module AST
     # Common functionality for nodes that are a kind of method dispatch:
-    # `send`, `csend`, `super`, `zsuper`, `yield`, `defined?`
+    # `send`, `csend`, `super`, `zsuper`, `yield`, `defined?`,
+    # and (modern only): `index`, `indexasgn`, `lambda`
     module MethodDispatchNode
       extend NodePattern::Macros
       include MethodIdentifierPredicates

data/lib/rubocop/ast/node/mixin/method_identifier_predicates.rb

@@ -6,15 +6,62 @@ module RuboCop
     # `send`, `csend`, `def`, `defs`, `super`, `zsuper`
     #
     # @note this mixin expects `#method_name` and `#receiver` to be implemented
-    module MethodIdentifierPredicates
+    module MethodIdentifierPredicates # rubocop:disable Metrics/ModuleLength
       ENUMERATOR_METHODS = %i[collect collect_concat detect downto each
                               find find_all find_index inject loop map!
                               map reduce reject reject! reverse_each select
-                              select! times upto].freeze
+                              select! times upto].to_set.freeze
+
+      ENUMERABLE_METHODS = (Enumerable.instance_methods + [:each]).to_set.freeze
 
       # http://phrogz.net/programmingruby/language.html#table_18.4
       OPERATOR_METHODS = %i[| ^ & <=> == === =~ > >= < <= << >> + - * /
-                            % ** ~ +@ -@ !@ ~@ [] []= ! != !~ `].freeze
+                            % ** ~ +@ -@ !@ ~@ [] []= ! != !~ `].to_set.freeze
+
+      NONMUTATING_BINARY_OPERATOR_METHODS = %i[* / % + - == === != < > <= >= <=>].to_set.freeze
+      NONMUTATING_UNARY_OPERATOR_METHODS = %i[+@ -@ ~ !].to_set.freeze
+      NONMUTATING_OPERATOR_METHODS = (NONMUTATING_BINARY_OPERATOR_METHODS +
+        NONMUTATING_UNARY_OPERATOR_METHODS).freeze
+
+      NONMUTATING_ARRAY_METHODS = %i[
+        all? any? assoc at bsearch bsearch_index collect
+        combination compact count cycle deconstruct difference
+        dig drop drop_while each each_index empty? eql?
+        fetch filter find_index first flatten hash
+        include? index inspect intersection join
+        last length map max min minmax none? one? pack
+        permutation product rassoc reject
+        repeated_combination repeated_permutation reverse
+        reverse_each rindex rotate sample select shuffle
+        size slice sort sum take take_while
+        to_a to_ary to_h to_s transpose union uniq
+        values_at zip |
+      ].to_set.freeze
+
+      NONMUTATING_HASH_METHODS = %i[
+        any? assoc compact dig each each_key each_pair
+        each_value empty? eql? fetch fetch_values filter
+        flatten has_key? has_value? hash include? inspect
+        invert key key? keys? length member? merge rassoc
+        rehash reject select size slice to_a to_h to_hash
+        to_proc to_s transform_keys transform_values value?
+        values values_at
+      ].to_set.freeze
+
+      NONMUTATING_STRING_METHODS = %i[
+        ascii_only? b bytes bytesize byteslice capitalize
+        casecmp casecmp? center chars chomp chop chr codepoints
+        count crypt delete delete_prefix delete_suffix
+        downcase dump each_byte each_char each_codepoint
+        each_grapheme_cluster each_line empty? encode encoding
+        end_with? eql? getbyte grapheme_clusters gsub hash
+        hex include index inspect intern length lines ljust lstrip
+        match match? next oct ord partition reverse rindex rjust
+        rpartition rstrip scan scrub size slice squeeze start_with?
+        strip sub succ sum swapcase to_a to_c to_f to_i to_r to_s
+        to_str to_sym tr tr_s unicode_normalize unicode_normalized?
+        unpack unpack1 upcase upto valid_encoding?
+      ].to_set.freeze
 
       # Checks whether the method name matches the argument.
       #
@@ -31,6 +78,48 @@ module RuboCop
         OPERATOR_METHODS.include?(method_name)
       end
 
+      # Checks whether the method is a nonmutating binary operator method.
+      #
+      # @return [Boolean] whether the method is a nonmutating binary operator method
+      def nonmutating_binary_operator_method?
+        NONMUTATING_BINARY_OPERATOR_METHODS.include?(method_name)
+      end
+
+      # Checks whether the method is a nonmutating unary operator method.
+      #
+      # @return [Boolean] whether the method is a nonmutating unary operator method
+      def nonmutating_unary_operator_method?
+        NONMUTATING_UNARY_OPERATOR_METHODS.include?(method_name)
+      end
+
+      # Checks whether the method is a nonmutating operator method.
+      #
+      # @return [Boolean] whether the method is a nonmutating operator method
+      def nonmutating_operator_method?
+        NONMUTATING_OPERATOR_METHODS.include?(method_name)
+      end
+
+      # Checks whether the method is a nonmutating Array method.
+      #
+      # @return [Boolean] whether the method is a nonmutating Array method
+      def nonmutating_array_method?
+        NONMUTATING_ARRAY_METHODS.include?(method_name)
+      end
+
+      # Checks whether the method is a nonmutating Hash method.
+      #
+      # @return [Boolean] whether the method is a nonmutating Hash method
+      def nonmutating_hash_method?
+        NONMUTATING_HASH_METHODS.include?(method_name)
+      end
+
+      # Checks whether the method is a nonmutating String method.
+      #
+      # @return [Boolean] whether the method is a nonmutating String method
+      def nonmutating_string_method?
+        NONMUTATING_STRING_METHODS.include?(method_name)
+      end
+
       # Checks whether the method is a comparison method.
       #
       # @return [Boolean] whether the method is a comparison
@@ -53,6 +142,13 @@ module RuboCop
           method_name.to_s.start_with?('each_')
       end
 
+      # Checks whether the method is an Enumerable method.
+      #
+      # @return [Boolean] whether the method is an Enumerable method
+      def enumerable_method?
+        ENUMERABLE_METHODS.include?(method_name)
+      end
+
       # Checks whether the method is a predicate method.
       #
       # @return [Boolean] whether the method is a predicate method

data/lib/rubocop/ast/node/mixin/parameterized_node.rb

@@ -4,6 +4,7 @@ module RuboCop
   module AST
     # Common functionality for nodes that are parameterized:
     # `send`, `super`, `zsuper`, `def`, `defs`
+    # and (modern only): `index`, `indexasgn`, `lambda`
     module ParameterizedNode
       # Checks whether this node's arguments are wrapped in parentheses.
       #

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

@@ -31,6 +31,62 @@ module RuboCop
       def content
         children.select(&:str_type?).map(&:str_content).join
       end
+
+      # @return [Bool] if the regexp is a /.../ literal
+      def slash_literal?
+        loc.begin.source == '/'
+      end
+
+      # @return [Bool] if the regexp is a %r{...} literal (using any delimiters)
+      def percent_r_literal?
+        !slash_literal?
+      end
+
+      # @return [String] the regexp delimiters (without %r)
+      def delimiters
+        [loc.begin.source[-1], loc.end.source[0]]
+      end
+
+      # @return [Bool] if char is one of the delimiters
+      def delimiter?(char)
+        delimiters.include?(char)
+      end
+
+      # @return [Bool] if regexp contains interpolation
+      def interpolation?
+        children.any?(&:begin_type?)
+      end
+
+      # @return [Bool] if regexp uses the multiline regopt
+      def multiline_mode?
+        regopt_include?(:m)
+      end
+
+      # @return [Bool] if regexp uses the extended regopt
+      def extended?
+        regopt_include?(:x)
+      end
+
+      # @return [Bool] if regexp uses the ignore-case regopt
+      def ignore_case?
+        regopt_include?(:i)
+      end
+
+      # @return [Bool] if regexp uses the single-interpolation regopt
+      def single_interpolation?
+        regopt_include?(:o)
+      end
+
+      # @return [Bool] if regexp uses the no-encoding regopt
+      def no_encoding?
+        regopt_include?(:n)
+      end
+
+      private
+
+      def regopt_include?(option)
+        regopt.children.include?(option)
+      end
     end
   end
 end

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

@@ -10,7 +10,8 @@ module RuboCop
       include MethodDispatchNode
 
       def_node_matcher :attribute_accessor?, <<~PATTERN
-        (send nil? ${:attr_reader :attr_writer :attr_accessor :attr} $...)
+        [(send nil? ${:attr_reader :attr_writer :attr_accessor :attr} $...)
+         (_    _    _                                                 _ ...)]
       PATTERN
     end
   end

data/lib/rubocop/ast/node_pattern.rb

@@ -70,13 +70,23 @@ module RuboCop
     #     '(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 #==
+    #                         # the AST using #=== so you can pass Procs, Regexp,
+    #                         # etc. in addition to Nodes or literals.
+    #                         # `Array#===` will never match a node element, but
+    #                         # `Set#===` is an alias to `Set#include?` (Ruby 2.5+
+    #                         # only), and so can be very useful to match within
+    #                         # many possible literals / Nodes.
     #                         # 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 _ %named)'   # arguments can also be passed as named
+    #                         # parameters (see `%1`)
+    #                         # Note that the macros `def_node_pattern` 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
     #                         # so this matches against the grandparent node
     #     '`send'             # descends any number of level in the AST
@@ -119,11 +129,13 @@ module RuboCop
         ).freeze
         NUMBER       = /-?\d+(?:\.\d+)?/.freeze
         STRING       = /".+?"/.freeze
-        METHOD_NAME  = /\#?#{IDENTIFIER}[\!\?]?\(?/.freeze
+        METHOD_NAME  = /\#?#{IDENTIFIER}[!?]?\(?/.freeze
+        PARAM_CONST  = /%[A-Z:][a-zA-Z_:]+/.freeze
+        KEYWORD_NAME = /%[a-z_]+/.freeze
         PARAM_NUMBER = /%\d*/.freeze
 
-        SEPARATORS = /[\s]+/.freeze
-        TOKENS     = Regexp.union(META, PARAM_NUMBER, NUMBER,
+        SEPARATORS = /\s+/.freeze
+        TOKENS     = Regexp.union(META, PARAM_CONST, KEYWORD_NAME, PARAM_NUMBER, NUMBER,
                                   METHOD_NAME, SYMBOL, STRING)
 
         TOKEN = /\G(?:#{SEPARATORS}|#{TOKENS}|.)/.freeze
@@ -135,6 +147,8 @@ module RuboCop
         FUNCALL   = /\A\##{METHOD_NAME}/.freeze
         LITERAL   = /\A(?:#{SYMBOL}|#{NUMBER}|#{STRING})\Z/.freeze
         PARAM     = /\A#{PARAM_NUMBER}\Z/.freeze
+        CONST     = /\A#{PARAM_CONST}\Z/.freeze
+        KEYWORD   = /\A#{KEYWORD_NAME}\Z/.freeze
         CLOSING   = /\A(?:\)|\}|\])\Z/.freeze
 
         REST      = '...'
@@ -193,6 +207,7 @@ module RuboCop
           @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)
         end
 
@@ -232,6 +247,8 @@ module RuboCop
           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')
@@ -612,7 +629,15 @@ module RuboCop
         end
 
         def compile_param(number)
-          "#{CUR_ELEMENT} == #{get_param(number)}"
+          "#{get_param(number)} === #{CUR_ELEMENT}"
+        end
+
+        def compile_const(const)
+          "#{get_const(const)} === #{CUR_ELEMENT}"
+        end
+
+        def compile_keyword(keyword)
+          "#{get_keyword(keyword)} === #{CUR_ELEMENT}"
         end
 
         def compile_args(tokens)
@@ -626,12 +651,14 @@ module RuboCop
         end
 
         def compile_arg(token)
+          name = token[1..-1]
           case token
-          when WILDCARD  then
-            name = token[1..-1]
+          when WILDCARD
             access_unify(name) || fail_due_to('invalid in arglist: ' + token)
           when LITERAL   then token
-          when PARAM     then get_param(token[1..-1])
+          when KEYWORD   then get_keyword(name)
+          when CONST     then get_const(name)
+          when PARAM     then get_param(name)
           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}")
@@ -650,6 +677,15 @@ module RuboCop
           number.zero? ? @root : "param#{number}"
         end
 
+        def get_keyword(name)
+          @keywords << name
+          name
+        end
+
+        def get_const(const)
+          const # Output the constant exactly as given
+        end
+
         def emit_yield_capture(when_no_capture = '')
           yield_val = if @captures.zero?
                         when_no_capture
@@ -675,9 +711,15 @@ module RuboCop
           (1..@params).map { |n| "param#{n}" }.join(',')
         end
 
-        def emit_trailing_params
+        def emit_keyword_list(forwarding: false)
+          pattern = "%<keyword>s: #{'%<keyword>s' if forwarding}"
+          @keywords.map { |k| format(pattern, keyword: k) }.join(',')
+        end
+
+        def emit_trailing_params(forwarding: false)
           params = emit_param_list
-          params.empty? ? '' : ",#{params}"
+          keywords = emit_keyword_list(forwarding: forwarding)
+          [params, keywords].reject(&:empty?).map { |p| ", #{p}" }.join
         end
 
         def emit_method_code
@@ -753,68 +795,51 @@ module RuboCop
         def self.tokens(pattern)
           pattern.scan(TOKEN).reject { |token| token =~ /\A#{SEPARATORS}\Z/ }
         end
-      end
-      private_constant :Compiler
-
-      # Helpers for defining methods based on a pattern string
-      module Macros
-        # Define a method which applies a pattern to an AST node
-        #
-        # The new method will return nil if the node does not match
-        # If the node matches, and a block is provided, the new method will
-        # yield to the block (passing any captures as block arguments).
-        # 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 = Compiler.new(pattern_str, 'node')
-          src = "def #{method_name}(node = self" \
-                "#{compiler.emit_trailing_params});" \
-                "#{compiler.emit_method_code};end"
-
-          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,
-        # checking whether any of them match the provided pattern
-        #
-        # If the method name ends with '?', the new method will return `true`
-        # 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 = Compiler.new(pattern_str, 'node')
-          called_from = caller(1..1).first.split(':')
-
-          if method_name.to_s.end_with?('?')
-            node_search_first(method_name, compiler, called_from)
-          else
-            node_search_all(method_name, compiler, called_from)
+        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}"
           end
+          src = yield method_name
+          base.class_eval(src, location.path, location.lineno)
         end
 
-        def node_search_first(method_name, compiler, called_from)
-          node_search(method_name, compiler, 'return true', '', called_from)
+        def def_node_matcher(base, method_name, **defaults)
+          def_helper(base, method_name, **defaults) do |name|
+            <<~RUBY
+              def #{name}(node = self#{emit_trailing_params})
+                #{emit_method_code}
+              end
+            RUBY
+          end
         end
 
-        def node_search_all(method_name, compiler, called_from)
-          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_code, prelude, called_from)
+        def def_node_search(base, method_name, **defaults)
+          def_helper(base, method_name, **defaults) do |name|
+            emit_node_search(name)
+          end
         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 = *called_from
-          class_eval(src, filename, lineno.to_i)
+        def emit_node_search(method_name)
+          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')
+          end
+          emit_node_search_body(method_name, prelude: prelude, on_match: on_match)
         end
 
-        def node_search_body(method_name, trailing_params, prelude, match_code,
-                             on_match)
+        def emit_node_search_body(method_name, prelude:, on_match:)
           <<~RUBY
-            def #{method_name}(node0#{trailing_params})
+            def #{method_name}(node0#{emit_trailing_params})
               #{prelude}
               node0.each_node do |node|
                 if #{match_code}
@@ -826,6 +851,33 @@ module RuboCop
           RUBY
         end
       end
+      private_constant :Compiler
+
+      # Helpers for defining methods based on a pattern string
+      module Macros
+        # Define a method which applies a pattern to an AST node
+        #
+        # The new method will return nil if the node does not match
+        # If the node matches, and a block is provided, the new method will
+        # yield to the block (passing any captures as block arguments).
+        # 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, **keyword_defaults)
+          Compiler.new(pattern_str, 'node')
+                  .def_node_matcher(self, method_name, **keyword_defaults)
+        end
+
+        # Define a method which recurses over the descendants of an AST node,
+        # checking whether any of them match the provided pattern
+        #
+        # If the method name ends with '?', the new method will return `true`
+        # 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')
+                  .def_node_search(self, method_name, **keyword_defaults)
+        end
+      end
 
       attr_reader :pattern
 
@@ -837,11 +889,15 @@ module RuboCop
         instance_eval(src, __FILE__, __LINE__ + 1)
       end
 
-      def match(*args)
+      def match(*args, **rest)
         # If we're here, it's because the singleton method has not been defined,
         # either because we've been dup'ed or serialized through YAML
         initialize(pattern)
-        match(*args)
+        if rest.empty?
+          match(*args)
+        else
+          match(*args, **rest)
+        end
       end
 
       def marshal_load(pattern)

data/lib/rubocop/ast/processed_source.rb

@@ -2,6 +2,7 @@
 
 require 'digest/sha1'
 
+# rubocop:disable Metrics/ClassLength
 module RuboCop
   module AST
     # ProcessedSource contains objects which are generated by Parser
@@ -176,6 +177,9 @@ module RuboCop
         when 2.7
           require 'parser/ruby27'
           Parser::Ruby27
+        when 2.8
+          require 'parser/ruby28'
+          Parser::Ruby28
         else
           raise ArgumentError,
                 "RuboCop found unknown Ruby version: #{ruby_version.inspect}"
@@ -201,3 +205,4 @@ module RuboCop
     end
   end
 end
+# rubocop:enable Metrics/ClassLength

data/lib/rubocop/ast/traversal.rb

@@ -19,9 +19,10 @@ module RuboCop
                              rational str sym regopt self lvar
                              ivar cvar gvar nth_ref back_ref cbase
                              arg restarg blockarg shadowarg
-                             kwrestarg zsuper lambda redo retry
+                             kwrestarg zsuper redo retry
                              forward_args forwarded_args
-                             match_var match_nil_pattern empty_else].freeze
+                             match_var match_nil_pattern empty_else
+                             forward_arg lambda procarg0 __ENCODING__].freeze
       ONE_CHILD_NODE    = %i[splat kwsplat block_pass not break next
                              preexe postexe match_current_line defined?
                              arg_expr pin match_rest if_guard unless_guard
@@ -33,7 +34,8 @@ module RuboCop
                              match_with_lvasgn begin kwbegin return
                              in_match match_alt
                              match_as array_pattern array_pattern_with_tail
-                             hash_pattern const_pattern].freeze
+                             hash_pattern const_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.0.3'
+      STRING = '0.1.0'
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-ast
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-15 00:00:00.000000000 Z
+date: 2020-06-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -77,8 +77,11 @@ files:
 - lib/rubocop/ast/node/forward_args_node.rb
 - lib/rubocop/ast/node/hash_node.rb
 - lib/rubocop/ast/node/if_node.rb
+- lib/rubocop/ast/node/index_node.rb
+- lib/rubocop/ast/node/indexasgn_node.rb
 - lib/rubocop/ast/node/int_node.rb
 - lib/rubocop/ast/node/keyword_splat_node.rb
+- lib/rubocop/ast/node/lambda_node.rb
 - lib/rubocop/ast/node/mixin/basic_literal_node.rb
 - lib/rubocop/ast/node/mixin/binary_operator_node.rb
 - lib/rubocop/ast/node/mixin/collection_node.rb
@@ -120,7 +123,7 @@ metadata:
   homepage_uri: https://www.rubocop.org/
   changelog_uri: https://github.com/rubocop-hq/rubocop-ast/blob/master/CHANGELOG.md
   source_code_uri: https://github.com/rubocop-hq/rubocop-ast/
-  documentation_uri: https://docs.rubocop.org/
+  documentation_uri: https://docs.rubocop.org/rubocop-ast/
   bug_tracker_uri: https://github.com/rubocop-hq/rubocop-ast/issues
 post_install_message: 
 rdoc_options: []