rubocop-ast 0.2.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d213ca265b42f0b66394057ee01a4a4573a28da98e7fc8caf52b5396fe098381
-  data.tar.gz: 3a351df6a7f11cfdad47b7844eb0c0d9860e11e7fdd65f5e1405b1f0978081be
+  metadata.gz: 329f01e23bc173bdcfec3cec5ef0eaf411f9328dbb7bef472e9ea119a2989427
+  data.tar.gz: 9208c40cf5063f525dcdf44eb43d65e05814fa76931f52c3015c391e3e99b77b
 SHA512:
-  metadata.gz: 1771b173896909ca2e9b68acf312c7b73e2e7308f834fc6d79871bd84b5012622e8727ab3e0cf98ca985cab32a70e65c83b174ff1bf42a59bba942720625b198
-  data.tar.gz: 57539ef58f3fc0722220759e4875524b43f9cd89a919d47429327f2ab3eaa2cfb0b35d9e275b05ac683f4f860bf5ac1986619fc16aa71c5a6b80ff2797683fa0
+  metadata.gz: 487a0aad608835a2a7b25f10d74e5430dded65f3c444dd5bfa3747b553c4811b09768c6966db4815adb1d529e4677930ed19e1a6b57ae7d0844f6d590265da55
+  data.tar.gz: c054ab24f0760a913e605fb8754e2c76faf993cc965695bafcba8c9e3b5ed333b20a3a6df7d442be7aa234ff98e881617f824bf9e8b38b8e9d86d72dc8e78ca0

data/README.md

@@ -35,8 +35,9 @@ See the [docs site](https://docs.rubocop.org/rubocop-ast) for more details.
 
 ### 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
+This gem, by default, uses most [legacy AST output from parser](https://github.com/whitequark/parser/#usage), except for `emit_forward_arg` which is set to `true`.
+
+The main `RuboCop` gem uses these defaults (and is currently only compatible with these), but this gem can be used separately from `RuboCop` and is meant to be compatible with all settings. For example, to have `-> { ... }` emitted
 as `LambdaNode` instead of `SendNode`:
 
 ```ruby

data/lib/rubocop/ast.rb

@@ -4,6 +4,8 @@ require 'parser'
 require 'forwardable'
 require 'set'
 
+require_relative 'ast/ext/range'
+require_relative 'ast/ext/set'
 require_relative 'ast/node_pattern'
 require_relative 'ast/sexp'
 require_relative 'ast/node'
@@ -27,6 +29,7 @@ require_relative 'ast/node/break_node'
 require_relative 'ast/node/case_match_node'
 require_relative 'ast/node/case_node'
 require_relative 'ast/node/class_node'
+require_relative 'ast/node/const_node'
 require_relative 'ast/node/def_node'
 require_relative 'ast/node/defined_node'
 require_relative 'ast/node/ensure_node'
@@ -41,12 +44,13 @@ 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/next_node'
 require_relative 'ast/node/or_node'
 require_relative 'ast/node/pair_node'
 require_relative 'ast/node/range_node'
 require_relative 'ast/node/regexp_node'
+require_relative 'ast/node/rescue_node'
 require_relative 'ast/node/resbody_node'
-require_relative 'ast/node/retry_node'
 require_relative 'ast/node/return_node'
 require_relative 'ast/node/self_class_node'
 require_relative 'ast/node/send_node'

data/lib/rubocop/ast/builder.rb

@@ -14,6 +14,8 @@ module RuboCop
     #   parser = Parser::Ruby25.new(builder)
     #   root_node = parser.parse(buffer)
     class Builder < Parser::Builders::Default
+      self.emit_forward_arg = true
+
       NODE_MAP = {
         and:          AndNode,
         alias:        AliasNode,
@@ -25,6 +27,7 @@ module RuboCop
         case_match:   CaseMatchNode,
         case:         CaseNode,
         class:        ClassNode,
+        const:        ConstNode,
         def:          DefNode,
         defined?:     DefinedNode,
         defs:         DefNode,
@@ -42,11 +45,12 @@ module RuboCop
         kwsplat:      KeywordSplatNode,
         lambda:       LambdaNode,
         module:       ModuleNode,
+        next:         NextNode,
         or:           OrNode,
         pair:         PairNode,
         regexp:       RegexpNode,
+        rescue:       RescueNode,
         resbody:      ResbodyNode,
-        retry:        RetryNode,
         return:       ReturnNode,
         csend:        SendNode,
         send:         SendNode,

data/lib/rubocop/ast/ext/range.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    module Ext
+      # Extensions to Parser::AST::Range
+      module Range
+        # @return [Range] the range of line numbers for the node
+        # If `exclude_end` is `true`, then the range will be exclusive.
+        #
+        # Assume that `node` corresponds to the following array literal:
+        #
+        #   [
+        #     :foo,
+        #     :bar
+        #   ]
+        #
+        #   node.loc.begin.line_span                         # => 1..1
+        #   node.loc.expression.line_span(exclude_end: true) # => 1...4
+        def line_span(exclude_end: false)
+          ::Range.new(first_line, last_line, exclude_end)
+        end
+      end
+    end
+  end
+end
+
+::Parser::Source::Range.include ::RuboCop::AST::Ext::Range

data/lib/rubocop/ast/ext/set.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+test = :foo
+case test
+when Set[:foo]
+  # ok, RUBY_VERSION > 2.4
+else
+  # Harmonize `Set#===`
+  class Set
+    alias === include?
+  end
+end

data/lib/rubocop/ast/node.rb

@@ -38,7 +38,7 @@ module RuboCop
       IMMUTABLE_LITERALS = (LITERALS - MUTABLE_LITERALS).freeze
 
       EQUALS_ASSIGNMENTS = %i[lvasgn ivasgn cvasgn gvasgn
-                              casgn masgn].freeze
+                              casgn masgn rasgn mrasgn].freeze
       SHORTHAND_ASSIGNMENTS = %i[op_asgn or_asgn and_asgn].freeze
       ASSIGNMENTS = (EQUALS_ASSIGNMENTS + SHORTHAND_ASSIGNMENTS).freeze
 
@@ -92,6 +92,16 @@ module RuboCop
         @mutable_attributes[:parent] = node
       end
 
+      # @return [Boolean]
+      def parent?
+        !!parent
+      end
+
+      # @return [Boolean]
+      def root?
+        !parent
+      end
+
       def complete!
         @mutable_attributes.freeze
         each_child_node(&:complete!)
@@ -116,12 +126,50 @@ module RuboCop
 
       # Returns the index of the receiver node in its siblings. (Sibling index
       # uses zero based numbering.)
+      # Use is discouraged, this is a potentially slow method.
       #
-      # @return [Integer] the index of the receiver node in its siblings
+      # @return [Integer, nil] the index of the receiver node in its siblings
       def sibling_index
         parent&.children&.index { |sibling| sibling.equal?(self) }
       end
 
+      # Use is discouraged, this is a potentially slow method and can lead
+      # to even slower algorithms
+      # @return [Node, nil] the right (aka next) sibling
+      def right_sibling
+        return unless parent
+
+        parent.children[sibling_index + 1].freeze
+      end
+
+      # Use is discouraged, this is a potentially slow method and can lead
+      # to even slower algorithms
+      # @return [Node, nil] the left (aka previous) sibling
+      def left_sibling
+        i = sibling_index
+        return if i.nil? || i.zero?
+
+        parent.children[i - 1].freeze
+      end
+
+      # Use is discouraged, this is a potentially slow method and can lead
+      # to even slower algorithms
+      # @return [Array<Node>] the left (aka previous) siblings
+      def left_siblings
+        return [].freeze unless parent
+
+        parent.children[0...sibling_index].freeze
+      end
+
+      # Use is discouraged, this is a potentially slow method and can lead
+      # to even slower algorithms
+      # @return [Array<Node>] the right (aka next) siblings
+      def right_siblings
+        return [].freeze unless parent
+
+        parent.children[sibling_index + 1..-1].freeze
+      end
+
       # Common destructuring method. This can be used to normalize
       # destructuring for different variations of the node.
       # Some node types override this with their own custom
@@ -261,8 +309,10 @@ module RuboCop
         self
       end
 
+      # Note: Some rare nodes may have no source, like `s(:args)` in `foo {}`
+      # @return [String, nil]
       def source
-        loc.expression.source
+        loc.expression&.source
       end
 
       def source_range

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

@@ -25,7 +25,7 @@ module RuboCop
       # @return [Array<Node>]
       def arguments
         if numblock_type?
-          [] # Numbered parameters have no block arguments.
+          [].freeze # Numbered parameters have no block arguments.
         else
           node_parts[1]
         end

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

@@ -6,12 +6,7 @@ module RuboCop
     # plain node when the builder constructs the AST, making its methods
     # available to all `break` nodes within RuboCop.
     class BreakNode < Node
-      include MethodDispatchNode
-      include ParameterizedNode
-
-      def arguments
-        []
-      end
+      include ParameterizedNode::WrappedArguments
     end
   end
 end

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

@@ -16,12 +16,10 @@ module RuboCop
       end
 
       # @deprecated Use `in_pattern_branches.each`
-      def each_in_pattern
+      def each_in_pattern(&block)
         return in_pattern_branches.to_enum(__method__) unless block_given?
 
-        in_pattern_branches.each do |condition|
-          yield condition
-        end
+        in_pattern_branches.each(&block)
 
         self
       end

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

@@ -16,12 +16,10 @@ module RuboCop
       end
 
       # @deprecated Use `when_branches.each`
-      def each_when
+      def each_when(&block)
         return when_branches.to_enum(__method__) unless block_given?
 
-        when_branches.each do |condition|
-          yield condition
-        end
+        when_branches.each(&block)
 
         self
       end
@@ -33,6 +31,16 @@ module RuboCop
         node_parts[1...-1]
       end
 
+      # Returns an array of all the when branches in the `case` statement.
+      #
+      # @return [Array<Node, nil>] an array of the bodies of the when branches
+      # and the else (if any). Note that these bodies could be nil.
+      def branches
+        bodies = when_branches.map(&:body)
+        bodies.push(else_branch) if else?
+        bodies
+      end
+
       # Returns the else branch of the `case` statement, if any.
       #
       # @return [Node] the else branch node of the `case` statement

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `const` nodes.
+    class ConstNode < Node
+      # The `send` node associated with this block.
+      #
+      # @return [Node, nil] the node associated with the scope (e.g. cbase, const, ...)
+      def namespace
+        children[0]
+      end
+
+      # @return [Symbol] the demodulized name of the constant: "::Foo::Bar" => :Bar
+      def short_name
+        children[1]
+      end
+
+      # The body of this block.
+      #
+      # @return [Boolean] if the constant is a Module / Class, according to the standard convention.
+      #                   Note: some classes might have uppercase in which case this method
+      #                         returns false
+      def module_name?
+        short_name.match?(/[[:lower:]]/)
+      end
+      alias class_name? module_name?
+
+      # @return [Boolean] if the constant starts with `::` (aka s(:cbase))
+      def absolute?
+        return false unless namespace
+
+        each_path.first.cbase_type?
+      end
+
+      # @return [Boolean] if the constant does not start with `::` (aka s(:cbase))
+      def relative?
+        !absolute?
+      end
+
+      # Yield nodes for the namespace
+      #
+      #   For `::Foo::Bar::BAZ` => yields:
+      #      s(:cbase), then
+      #      s(:const, :Foo), then
+      #      s(:const, s(:const, :Foo), :Bar)
+      def each_path(&block)
+        return to_enum(__method__) unless block_given?
+
+        descendants = []
+        last = self
+        loop do
+          last = last.children.first
+          break if last.nil?
+
+          descendants << last
+          break unless last.const_type?
+        end
+        descendants.reverse_each(&block)
+
+        self
+      end
+    end
+  end
+end

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

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

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

@@ -6,6 +6,7 @@ module RuboCop
     # node when the builder constructs the AST, making its methods available to
     # all `float` nodes within RuboCop.
     class FloatNode < Node
+      include BasicLiteralNode
       include NumericNode
     end
   end

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

@@ -56,12 +56,10 @@ module RuboCop
       #
       # @return [self] if a block is given
       # @return [Enumerator] if no block is given
-      def each_key
+      def each_key(&block)
         return pairs.map(&:key).to_enum unless block_given?
 
-        pairs.map(&:key).each do |key|
-          yield key
-        end
+        pairs.map(&:key).each(&block)
 
         self
       end
@@ -82,12 +80,10 @@ module RuboCop
       #
       # @return [self] if a block is given
       # @return [Enumerator] if no block is given
-      def each_value
+      def each_value(&block)
         return pairs.map(&:value).to_enum unless block_given?
 
-        pairs.map(&:value).each do |value|
-          yield value
-        end
+        pairs.map(&:value).each(&block)
 
         self
       end

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

@@ -147,7 +147,7 @@ module RuboCop
       def branches
         branches = [if_branch]
 
-        return branches unless else_branch
+        return branches unless else?
 
         other_branches = if elsif_conditional?
                            else_branch.branches
@@ -158,12 +158,10 @@ module RuboCop
       end
 
       # @deprecated Use `branches.each`
-      def each_branch
+      def each_branch(&block)
         return branches.to_enum(__method__) unless block_given?
 
-        branches.each do |branch|
-          yield branch
-        end
+        branches.each(&block)
       end
     end
   end

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

@@ -17,7 +17,7 @@ module RuboCop
     # 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 ParameterizedNode::RestArguments
       include MethodDispatchNode
 
       # For similarity with legacy mode
@@ -35,11 +35,13 @@ module RuboCop
         :[]
       end
 
+      private
+
       # An array containing the arguments of the dispatched method.
       #
       # @return [Array<Node>] the arguments of the dispatched method
-      def arguments
-        node_parts[1..-1]
+      def first_argument_index
+        1
       end
     end
   end

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

@@ -19,7 +19,7 @@ module RuboCop
     # 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 ParameterizedNode::RestArguments
       include MethodDispatchNode
 
       # For similarity with legacy mode
@@ -37,11 +37,13 @@ module RuboCop
         :[]=
       end
 
+      private
+
       # An array containing the arguments of the dispatched method.
       #
       # @return [Array<Node>] the arguments of the dispatched method
-      def arguments
-        node_parts[1..-1]
+      def first_argument_index
+        1
       end
     end
   end

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

@@ -6,6 +6,7 @@ module RuboCop
     # node when the builder constructs the AST, making its methods available to
     # all `int` nodes within RuboCop.
     class IntNode < Node
+      include BasicLiteralNode
       include NumericNode
     end
   end

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

@@ -21,7 +21,7 @@ module RuboCop
     # 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 ParameterizedNode::RestArguments
       include MethodDispatchNode
 
       # For similarity with legacy mode
@@ -44,14 +44,21 @@ module RuboCop
         false
       end
 
+      # For similarity with legacy mode
+      def receiver
+        nil
+      end
+
       # For similarity with legacy mode
       def method_name
         :lambda
       end
 
+      private
+
       # For similarity with legacy mode
-      def arguments
-        []
+      def first_argument_index
+        2
       end
     end
   end

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

@@ -26,13 +26,6 @@ module RuboCop
         node_parts[1]
       end
 
-      # An array containing the arguments of the dispatched method.
-      #
-      # @return [Array<Node>] the arguments of the dispatched method
-      def arguments
-        node_parts[2..-1]
-      end
-
       # The `block` node associated with this method dispatch, if any.
       #
       # @return [BlockNode, nil] the `block` node associated with this method

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

@@ -2,6 +2,8 @@
 
 module RuboCop
   module AST
+    # Requires implementing `arguments`.
+    #
     # Common functionality for nodes that are parameterized:
     # `send`, `super`, `zsuper`, `def`, `defs`
     # and (modern only): `index`, `indexasgn`, `lambda`
@@ -57,6 +59,59 @@ module RuboCop
         arguments? &&
           (last_argument.block_pass_type? || last_argument.blockarg_type?)
       end
+
+      # A specialized `ParameterizedNode` for node that have a single child
+      # containing either `nil`, an argument, or a `begin` node with all the
+      # arguments
+      module WrappedArguments
+        include ParameterizedNode
+        # @return [Array] The arguments of the node.
+        def arguments
+          first = children.first
+          if first&.begin_type?
+            first.children
+          else
+            children
+          end
+        end
+      end
+
+      # A specialized `ParameterizedNode`.
+      # Requires implementing `first_argument_index`
+      # Implements `arguments` as `children[first_argument_index..-1]`
+      # and optimizes other calls
+      module RestArguments
+        include ParameterizedNode
+        # @return [Array<Node>] arguments, if any
+        def arguments
+          children[first_argument_index..-1].freeze
+        end
+
+        # A shorthand for getting the first argument of the node.
+        # Equivalent to `arguments.first`.
+        #
+        # @return [Node, nil] the first argument of the node,
+        #                     or `nil` if there are no arguments
+        def first_argument
+          children[first_argument_index]
+        end
+
+        # A shorthand for getting the last argument of the node.
+        # Equivalent to `arguments.last`.
+        #
+        # @return [Node, nil] the last argument of the node,
+        #                     or `nil` if there are no arguments
+        def last_argument
+          children[-1] if arguments?
+        end
+
+        # Checks whether this node has any arguments.
+        #
+        # @return [Boolean] whether this node has any arguments
+        def arguments?
+          children.size > first_argument_index
+        end
+      end
     end
   end
 end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `next` nodes. This will be used in place of a
+    # plain node when the builder constructs the AST, making its methods
+    # available to all `next` nodes within RuboCop.
+    class NextNode < Node
+      include ParameterizedNode::WrappedArguments
+    end
+  end
+end

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

@@ -32,7 +32,7 @@ module RuboCop
       #
       # @param [Boolean] with_spacing whether to include spacing
       # @return [String] the delimiter of the `pair`
-      def delimiter(with_spacing = false)
+      def delimiter(*deprecated, with_spacing: deprecated.first)
         if with_spacing
           hash_rocket? ? SPACED_HASH_ROCKET : SPACED_COLON
         else
@@ -44,7 +44,7 @@ module RuboCop
       #
       # @param [Boolean] with_spacing whether to include spacing
       # @return [String] the inverse delimiter of the `pair`
-      def inverse_delimiter(with_spacing = false)
+      def inverse_delimiter(*deprecated, with_spacing: deprecated.first)
         if with_spacing
           hash_rocket? ? SPACED_COLON : SPACED_HASH_ROCKET
         else

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

@@ -13,12 +13,33 @@ module RuboCop
         node_parts[2]
       end
 
+      # Returns an array of all the exceptions in the `rescue` clause.
+      #
+      # @return [Array<Node>] an array of exception nodes
+      def exceptions
+        exceptions_node = node_parts[0]
+        if exceptions_node.nil?
+          []
+        elsif exceptions_node.array_type?
+          exceptions_node.values
+        else
+          [exceptions_node]
+        end
+      end
+
       # Returns the exception variable of the `rescue` clause.
       #
       # @return [Node, nil] The exception variable of the `resbody`.
       def exception_variable
         node_parts[1]
       end
+
+      # Returns the index of the `resbody` branch within the exception handling statement.
+      #
+      # @return [Integer] the index of the `resbody` branch
+      def branch_index
+        parent.resbody_branches.index(self)
+      end
     end
   end
 end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    # A node extension for `rescue` nodes. This will be used in place of a
+    # plain node when the builder constructs the AST, making its methods
+    # available to all `rescue` nodes within RuboCop.
+    class RescueNode < Node
+      # Returns the body of the rescue node.
+      #
+      # @return [Node, nil] The body of the rescue node.
+      def body
+        node_parts[0]
+      end
+
+      # Returns an array of all the rescue branches in the exception handling statement.
+      #
+      # @return [Array<ResbodyNode>] an array of `resbody` nodes
+      def resbody_branches
+        node_parts[1...-1]
+      end
+
+      # Returns an array of all the rescue branches in the exception handling statement.
+      #
+      # @return [Array<Node, nil>] an array of the bodies of the rescue branches
+      # and the else (if any). Note that these bodies could be nil.
+      def branches
+        bodies = resbody_branches.map(&:body)
+        bodies.push(else_branch) if else?
+        bodies
+      end
+
+      # Returns the else branch of the exception handling statement, if any.
+      #
+      # @return [Node] the else branch node of the exception handling statement
+      # @return [nil] if the exception handling statement does not have an else branch.
+      def else_branch
+        node_parts[-1]
+      end
+
+      # Checks whether this exception handling statement has an `else` branch.
+      #
+      # @return [Boolean] whether the exception handling statement has an `else` branch
+      def else?
+        loc.else
+      end
+    end
+  end
+end

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

@@ -6,19 +6,7 @@ module RuboCop
     # plain node when the builder constructs the AST, making its methods
     # available to all `return` nodes within RuboCop.
     class ReturnNode < Node
-      include MethodDispatchNode
-      include ParameterizedNode
-
-      # Returns the arguments of the `return`.
-      #
-      # @return [Array] The arguments of the `return`.
-      def arguments
-        if node_parts.one? && node_parts.first.begin_type?
-          node_parts.first.children
-        else
-          node_parts
-        end
-      end
+      include ParameterizedNode::WrappedArguments
     end
   end
 end

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

@@ -14,12 +14,10 @@ module RuboCop
       end
 
       # @deprecated Use `conditions.each`
-      def each_condition
+      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

@@ -99,6 +99,7 @@ module RuboCop
     #                         # 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:
     #
@@ -122,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
@@ -202,7 +205,7 @@ module RuboCop
 
         def initialize(str, root = 'node0', node_var = root)
           @string   = str
-          # For def_node_pattern, 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
@@ -455,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
@@ -475,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?
@@ -790,7 +791,7 @@ module RuboCop
         end
 
         def self.tokens(pattern)
-          pattern.scan(TOKEN).grep_v(ONLY_SEPARATOR)
+          pattern.gsub(COMMENT, '').scan(TOKEN).grep_v(ONLY_SEPARATOR)
         end
 
         # This method minimizes the closure for our method

data/lib/rubocop/ast/processed_source.rb

@@ -72,23 +72,23 @@ module RuboCop
       end
 
       # @deprecated Use `comments.each`
-      def each_comment
-        comments.each { |comment| yield comment }
+      def each_comment(&block)
+        comments.each(&block)
       end
 
-      # @deprecated Use `comments.find`
-      def find_comment
-        comments.find { |comment| yield comment }
+      # @deprecated Use `comment_at_line`, `each_comment_in_lines`, or `comments.find`
+      def find_comment(&block)
+        comments.find(&block)
       end
 
       # @deprecated Use `tokens.each`
-      def each_token
-        tokens.each { |token| yield token }
+      def each_token(&block)
+        tokens.each(&block)
       end
 
       # @deprecated Use `tokens.find`
-      def find_token
-        tokens.find { |token| yield token }
+      def find_token(&block)
+        tokens.find(&block)
       end
 
       def file_path
@@ -99,22 +99,39 @@ module RuboCop
         ast.nil?
       end
 
+      # @return [Comment, nil] the comment at that line, if any.
+      def comment_at_line(line)
+        comment_index[line]
+      end
+
       # @return [Boolean] if the given line number has a comment.
       def line_with_comment?(line)
-        comment_lines.include?(line)
+        comment_index.include?(line)
+      end
+
+      # Enumerates on the comments contained with the given `line_range`
+      def each_comment_in_lines(line_range)
+        return to_enum(:each_comment_in_lines, line_range) unless block_given?
+
+        line_range.each do |line|
+          if (comment = comment_index[line])
+            yield comment
+          end
+        end
       end
 
       # @return [Boolean] if any of the lines in the given `source_range` has a comment.
+      # Consider using `each_comment_in_lines` instead
       def contains_comment?(source_range)
-        (source_range.line..source_range.last_line).any? do |line|
-          line_with_comment?(line)
-        end
+        each_comment_in_lines(source_range.line..source_range.last_line).any?
       end
       # @deprecated use contains_comment?
       alias commented? contains_comment?
 
+      # @deprecated Use `each_comment_in_lines`
+      # Should have been called `comments_before_or_at_line`. Doubtful it has of any valid use.
       def comments_before_line(line)
-        comments.select { |c| c.location.line <= line }
+        each_comment_in_lines(0..line).to_a
       end
 
       def start_with?(string)
@@ -142,10 +159,26 @@ module RuboCop
           .length
       end
 
+      def tokens_within(range_or_node)
+        begin_index = first_token_index(range_or_node)
+        end_index = last_token_index(range_or_node)
+        sorted_tokens[begin_index..end_index]
+      end
+
+      def first_token_of(range_or_node)
+        sorted_tokens[first_token_index(range_or_node)]
+      end
+
+      def last_token_of(range_or_node)
+        sorted_tokens[last_token_index(range_or_node)]
+      end
+
       private
 
-      def comment_lines
-        @comment_lines ||= comments.map { |c| c.location.line }
+      def comment_index
+        @comment_index ||= {}.tap do |hash|
+          comments.each { |c| hash[c.location.line] = c }
+        end
       end
 
       def parse(source, ruby_version)
@@ -156,6 +189,9 @@ module RuboCop
           @buffer.source = source
         rescue EncodingError => e
           @parser_error = e
+          @ast = nil
+          @comments = []
+          @tokens = []
           return
         end
 
@@ -165,13 +201,15 @@ module RuboCop
       def tokenize(parser)
         begin
           ast, comments, tokens = parser.tokenize(@buffer)
-
-          ast.respond_to?(:complete!) && ast.complete!
+          ast ||= nil # force `false` to `nil`, see https://github.com/whitequark/parser/pull/722
         rescue Parser::SyntaxError
           # All errors are in diagnostics. No need to handle exception.
+          comments = []
+          tokens = []
         end
 
-        tokens = tokens.map { |t| Token.from_parser_token(t) } if tokens
+        ast&.complete!
+        tokens.map! { |t| Token.from_parser_token(t) }
 
         [ast, comments, tokens]
       end
@@ -191,9 +229,9 @@ module RuboCop
         when 2.7
           require 'parser/ruby27'
           Parser::Ruby27
-        when 2.8
-          require 'parser/ruby28'
-          Parser::Ruby28
+        when 2.8, 3.0
+          require 'parser/ruby30'
+          Parser::Ruby30
         else
           raise ArgumentError,
                 "RuboCop found unknown Ruby version: #{ruby_version.inspect}"
@@ -216,6 +254,32 @@ module RuboCop
           end
         end
       end
+
+      def first_token_index(range_or_node)
+        begin_pos = source_range(range_or_node).begin_pos
+        sorted_tokens.bsearch_index { |token| token.begin_pos >= begin_pos }
+      end
+
+      def last_token_index(range_or_node)
+        end_pos = source_range(range_or_node).end_pos
+        sorted_tokens.bsearch_index { |token| token.end_pos >= end_pos }
+      end
+
+      # The tokens list is always sorted by token position, except for cases when heredoc
+      # is passed as a method argument. In this case tokens are interleaved by
+      # heredoc contents' tokens.
+      def sorted_tokens
+        # Use stable sort.
+        @sorted_tokens ||= tokens.sort_by.with_index { |token, i| [token.begin_pos, i] }
+      end
+
+      def source_range(range_or_node)
+        if range_or_node.respond_to?(:source_range)
+          range_or_node.source_range
+        else
+          range_or_node
+        end
+      end
     end
   end
 end

data/lib/rubocop/ast/traversal.rb

@@ -28,7 +28,7 @@ module RuboCop
                              arg_expr pin match_rest if_guard unless_guard
                              match_with_trailing_comma].freeze
       MANY_CHILD_NODES  = %i[dstr dsym xstr regexp array hash pair
-                             mlhs masgn or_asgn and_asgn
+                             mlhs masgn or_asgn and_asgn rasgn mrasgn
                              undef alias args super yield or and
                              while_post until_post iflipflop eflipflop
                              match_with_lvasgn begin kwbegin return

data/lib/rubocop/ast/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubocop-ast
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Bozhidar Batsov
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-07-19 00:00:00.000000000 Z
+date: 2020-09-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: parser
@@ -18,14 +18,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.7.0.1
+        version: 2.7.1.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.7.0.1
+        version: 2.7.1.5
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -59,6 +59,8 @@ files:
 - lib/rubocop-ast.rb
 - lib/rubocop/ast.rb
 - lib/rubocop/ast/builder.rb
+- lib/rubocop/ast/ext/range.rb
+- lib/rubocop/ast/ext/set.rb
 - lib/rubocop/ast/node.rb
 - lib/rubocop/ast/node/alias_node.rb
 - lib/rubocop/ast/node/and_node.rb
@@ -69,6 +71,7 @@ files:
 - lib/rubocop/ast/node/case_match_node.rb
 - lib/rubocop/ast/node/case_node.rb
 - lib/rubocop/ast/node/class_node.rb
+- lib/rubocop/ast/node/const_node.rb
 - lib/rubocop/ast/node/def_node.rb
 - lib/rubocop/ast/node/defined_node.rb
 - lib/rubocop/ast/node/ensure_node.rb
@@ -94,12 +97,13 @@ files:
 - lib/rubocop/ast/node/mixin/parameterized_node.rb
 - lib/rubocop/ast/node/mixin/predicate_operator_node.rb
 - lib/rubocop/ast/node/module_node.rb
+- lib/rubocop/ast/node/next_node.rb
 - lib/rubocop/ast/node/or_node.rb
 - lib/rubocop/ast/node/pair_node.rb
 - lib/rubocop/ast/node/range_node.rb
 - lib/rubocop/ast/node/regexp_node.rb
 - lib/rubocop/ast/node/resbody_node.rb
-- lib/rubocop/ast/node/retry_node.rb
+- lib/rubocop/ast/node/rescue_node.rb
 - lib/rubocop/ast/node/return_node.rb
 - lib/rubocop/ast/node/self_class_node.rb
 - lib/rubocop/ast/node/send_node.rb

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

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module RuboCop
-  module AST
-    # A node extension for `retry` nodes. This will be used in place of a
-    # plain node when the builder constructs the AST, making its methods
-    # available to all `retry` nodes within RuboCop.
-    class RetryNode < Node
-      include MethodDispatchNode
-      include ParameterizedNode
-
-      def arguments
-        []
-      end
-    end
-  end
-end