rubocop-ast 1.24.1 → 1.46.0

data/lib/rubocop/ast/node.rb

@@ -76,9 +76,6 @@ module RuboCop
       OPERATOR_KEYWORDS = %i[and or].to_set.freeze
       # @api private
       SPECIAL_KEYWORDS = %w[__FILE__ __LINE__ __ENCODING__].to_set.freeze
-      # @api private
-      ARGUMENT_TYPES = %i[arg optarg restarg kwarg kwoptarg kwrestarg
-                          blockarg forward_arg shadowarg].to_set.freeze
 
       LITERAL_RECURSIVE_METHODS = (COMPARISON_OPERATORS + %i[* ! <=>]).freeze
       LITERAL_RECURSIVE_TYPES = (OPERATOR_KEYWORDS + COMPOSITE_LITERALS + %i[begin pair]).freeze
@@ -88,6 +85,65 @@ module RuboCop
       EMPTY_PROPERTIES = {}.freeze
       private_constant :EMPTY_CHILDREN, :EMPTY_PROPERTIES
 
+      # @api private
+      GROUP_FOR_TYPE = {
+        def: :any_def,
+        defs: :any_def,
+
+        arg: :argument,
+        optarg: :argument,
+        restarg: :argument,
+        kwarg: :argument,
+        kwoptarg: :argument,
+        kwrestarg: :argument,
+        blockarg: :argument,
+        forward_arg: :argument,
+        shadowarg: :argument,
+
+        true: :boolean,
+        false: :boolean,
+
+        int: :numeric,
+        float: :numeric,
+        rational: :numeric,
+        complex: :numeric,
+
+        irange: :range,
+        erange: :range,
+
+        send: :call,
+        csend: :call,
+
+        block: :any_block,
+        numblock: :any_block,
+        itblock: :any_block,
+
+        match_pattern: :any_match_pattern,
+        match_pattern_p: :any_match_pattern
+      }.freeze
+      private_constant :GROUP_FOR_TYPE
+
+      # Define a +recursive_?+ predicate method for the given node kind.
+      private_class_method def self.def_recursive_literal_predicate(kind) # rubocop:disable Metrics/MethodLength
+        recursive_kind = "recursive_#{kind}?"
+        kind_filter = "#{kind}?"
+
+        class_eval <<~RUBY, __FILE__, __LINE__ + 1
+          def #{recursive_kind}                                     # def recursive_literal?
+            case type                                               #   case type
+            when :send                                              #   when :send
+              LITERAL_RECURSIVE_METHODS.include?(method_name) &&    #     LITERAL_RECURSIVE_METHODS.include?(method_name) &&
+                receiver.send(:#{recursive_kind}) &&                #       receiver.send(:recursive_literal?) &&
+                arguments.all?(&:#{recursive_kind})                 #       arguments.all?(&:recursive_literal?)
+            when LITERAL_RECURSIVE_TYPES                            #   when LITERAL_RECURSIVE_TYPES
+              children.compact.all?(&:#{recursive_kind})            #     children.compact.all?(&:recursive_literal?)
+            else                                                    #   else
+              send(:#{kind_filter})                                 #     send(:literal?)
+            end                                                     #   end
+          end                                                       # end
+        RUBY
+      end
+
       # @see https://www.rubydoc.info/gems/ast/AST/Node:initialize
       def initialize(type, children = EMPTY_CHILDREN, properties = EMPTY_PROPERTIES)
         @mutable_attributes = {}
@@ -105,6 +161,16 @@ module RuboCop
         end
       end
 
+      # Determine if the node is one of several node types in a single query
+      # Allows specific single node types, as well as "grouped" types
+      # (e.g. `:boolean` for `:true` or `:false`)
+      def type?(*types)
+        return true if types.include?(type)
+
+        group_type = GROUP_FOR_TYPE[type]
+        !group_type.nil? && types.include?(group_type)
+      end
+
       (Parser::Meta::NODE_TYPES - [:send]).each do |node_type|
         method_name = "#{node_type.to_s.gsub(/\W/, '')}_type?"
         class_eval <<~RUBY, __FILE__, __LINE__ + 1
@@ -206,7 +272,7 @@ module RuboCop
       def right_siblings
         return [].freeze unless parent
 
-        parent.children[sibling_index + 1..].freeze
+        parent.children[(sibling_index + 1)..].freeze
       end
 
       # Common destructuring method. This can be used to normalize
@@ -284,20 +350,19 @@ module RuboCop
 
       # @!method receiver(node = self)
       def_node_matcher :receiver, <<~PATTERN
-        {(send $_ ...) ({block numblock} (call $_ ...) ...)}
+        {(send $_ ...) (any_block (call $_ ...) ...)}
       PATTERN
 
       # @!method str_content(node = self)
       def_node_matcher :str_content, '(str $_)'
 
       def const_name
-        return unless const_type?
+        return unless const_type? || casgn_type?
 
-        namespace, name = *self
         if namespace && !namespace.cbase_type?
-          "#{namespace.const_name}::#{name}"
+          "#{namespace.const_name}::#{short_name}"
         else
-          name.to_s
+          short_name.to_s
         end
       end
 
@@ -326,13 +391,13 @@ module RuboCop
         # what class or module is this method/constant/etc definition in?
         # returns nil if answer cannot be determined
         ancestors = each_ancestor(:class, :module, :sclass, :casgn, :block)
-        result    = ancestors.map do |ancestor|
+        result    = ancestors.filter_map do |ancestor|
           parent_module_name_part(ancestor) do |full_name|
             return nil unless full_name
 
             full_name
           end
-        end.compact.reverse.join('::')
+        end.reverse.join('::')
         result.empty? ? 'Object' : result
       end
 
@@ -380,22 +445,11 @@ module RuboCop
         IMMUTABLE_LITERALS.include?(type)
       end
 
-      %i[literal basic_literal].each do |kind|
-        recursive_kind = :"recursive_#{kind}?"
-        kind_filter = :"#{kind}?"
-        define_method(recursive_kind) do
-          case type
-          when :send
-            LITERAL_RECURSIVE_METHODS.include?(method_name) &&
-              receiver.send(recursive_kind) &&
-              arguments.all?(&recursive_kind)
-          when LITERAL_RECURSIVE_TYPES
-            children.compact.all?(&recursive_kind)
-          else
-            send(kind_filter)
-          end
-        end
-      end
+      # @!macro [attach] def_recursive_literal_predicate
+      #   @!method recursive_$1?
+      #     @return [Boolean]
+      def_recursive_literal_predicate :literal
+      def_recursive_literal_predicate :basic_literal
 
       def variable?
         VARIABLES.include?(type)
@@ -450,11 +504,11 @@ module RuboCop
       end
 
       def parenthesized_call?
-        loc.respond_to?(:begin) && loc.begin && loc.begin.is?('(')
+        loc_is?(:begin, '(')
       end
 
       def call_type?
-        send_type? || csend_type?
+        GROUP_FOR_TYPE[type] == :call
       end
 
       def chained?
@@ -465,28 +519,56 @@ module RuboCop
         parent&.send_type? && parent.arguments.include?(self)
       end
 
+      def any_def_type?
+        GROUP_FOR_TYPE[type] == :any_def
+      end
+
       def argument_type?
-        ARGUMENT_TYPES.include?(type)
+        GROUP_FOR_TYPE[type] == :argument
       end
 
       def boolean_type?
-        true_type? || false_type?
+        GROUP_FOR_TYPE[type] == :boolean
       end
 
       def numeric_type?
-        int_type? || float_type? || rational_type? || complex_type?
+        GROUP_FOR_TYPE[type] == :numeric
       end
 
       def range_type?
-        irange_type? || erange_type?
+        GROUP_FOR_TYPE[type] == :range
+      end
+
+      def any_block_type?
+        GROUP_FOR_TYPE[type] == :any_block
+      end
+
+      def any_match_pattern_type?
+        GROUP_FOR_TYPE[type] == :any_match_pattern
       end
 
       def guard_clause?
-        node = and_type? || or_type? ? rhs : self
+        node = operator_keyword? ? rhs : self
 
         node.match_guard_clause?
       end
 
+      # Shortcut to safely check if a location is present
+      # @return [Boolean]
+      def loc?(which_loc)
+        return false unless loc.respond_to?(which_loc)
+
+        !loc.public_send(which_loc).nil?
+      end
+
+      # Shortcut to safely test a particular location, even if
+      # this location does not exist or is `nil`
+      def loc_is?(which_loc, str)
+        return false unless loc?(which_loc)
+
+        loc.public_send(which_loc).is?(str)
+      end
+
       # @!method match_guard_clause?(node = self)
       def_node_matcher :match_guard_clause?, <<~PATTERN
         [${(send nil? {:raise :fail} ...) return break next} single_line?]
@@ -500,7 +582,7 @@ module RuboCop
       PATTERN
 
       # @!method lambda?(node = self)
-      def_node_matcher :lambda?, '({block numblock} (send nil? :lambda) ...)'
+      def_node_matcher :lambda?, '(any_block (send nil? :lambda) ...)'
 
       # @!method lambda_or_proc?(node = self)
       def_node_matcher :lambda_or_proc?, '{lambda? proc?}'
@@ -510,27 +592,33 @@ module RuboCop
 
       # @!method class_constructor?(node = self)
       def_node_matcher :class_constructor?, <<~PATTERN
-        {       (send #global_const?({:Class :Module :Struct}) :new ...)
-         (block (send #global_const?({:Class :Module :Struct}) :new ...) ...)}
+        {
+          (send #global_const?({:Class :Module :Struct}) :new ...)
+          (send #global_const?(:Data) :define ...)
+          (any_block {
+            (send #global_const?({:Class :Module :Struct}) :new ...)
+            (send #global_const?(:Data) :define ...)
+          } ...)
+        }
       PATTERN
 
       # @deprecated Use `:class_constructor?`
       # @!method struct_constructor?(node = self)
       def_node_matcher :struct_constructor?, <<~PATTERN
-        ({block numblock} (send #global_const?(:Struct) :new ...) _ $_)
+        (any_block (send #global_const?(:Struct) :new ...) _ $_)
       PATTERN
 
       # @!method class_definition?(node = self)
       def_node_matcher :class_definition?, <<~PATTERN
         {(class _ _ $_)
          (sclass _ $_)
-         ({block numblock} (send #global_const?({:Struct :Class}) :new ...) _ $_)}
+         (any_block (send #global_const?({:Struct :Class}) :new ...) _ $_)}
       PATTERN
 
       # @!method module_definition?(node = self)
       def_node_matcher :module_definition?, <<~PATTERN
         {(module _ $_)
-         ({block numblock} (send #global_const?(:Module) :new ...) _ $_)}
+         (any_block (send #global_const?(:Module) :new ...) _ $_)}
       PATTERN
 
       # Some expressions are evaluated for their value, some for their side
@@ -541,8 +629,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
-      def value_used?
+      def value_used? # rubocop:disable Metrics/MethodLength
         # Be conservative and return true if we're not sure.
         return false if parent.nil?
 
@@ -563,7 +650,6 @@ module RuboCop
           true
         end
       end
-      # rubocop:enable Metrics/MethodLength
 
       # Some expressions are evaluated for their value, some for their side
       # effects, and some for both.
@@ -595,8 +681,7 @@ module RuboCop
         last_node = self
 
         while (current_node = last_node.parent)
-          yield current_node if types.empty? ||
-                                types.include?(current_node.type)
+          yield current_node if types.empty? || current_node.type?(*types)
           last_node = current_node
         end
       end
@@ -615,7 +700,7 @@ module RuboCop
       def case_if_value_used?
         # (case <condition> <when...>)
         # (if <condition> <truebranch> <falsebranch>)
-        sibling_index.zero? ? true : parent.value_used?
+        sibling_index.zero? || parent.value_used?
       end
 
       def while_until_value_used?

data/lib/rubocop/ast/node_pattern/compiler/atom_subcompiler.rb

@@ -38,7 +38,7 @@ module RuboCop
           end
 
           def visit_set
-            set = node.children.map(&:child).to_set.freeze
+            set = node.children.to_set(&:child).freeze
             NodePattern::Sets[set]
           end
 

data/lib/rubocop/ast/node_pattern/compiler/binding.rb

@@ -26,8 +26,9 @@ module RuboCop
             var
           end
 
-          # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-          def union_bind(enum)
+          # Yields for each branch of the given union, forbidding unification of
+          # bindings which only appear in a subset of the union.
+          def union_bind(enum) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
             # We need to reset @bound before each branch is processed.
             # Moreover we need to keep track of newly encountered wildcards.
             # Var `newly_bound_intersection` will hold those that are encountered
@@ -62,7 +63,6 @@ module RuboCop
 
             result
           end
-          # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
           private
 

data/lib/rubocop/ast/node_pattern/compiler/debug.rb

@@ -15,10 +15,12 @@ module RuboCop
               @visit = {}
             end
 
+            # rubocop:disable Naming/PredicateMethod
             def enter(node_id)
               @visit[node_id] = false
               true
             end
+            # rubocop:enable Naming/PredicateMethod
 
             def success(node_id)
               @visit[node_id] = true
@@ -47,7 +49,7 @@ module RuboCop
               # @return [String] a Rainbow colorized version of ruby
               def colorize(color_scheme = COLOR_SCHEME)
                 map = color_map(color_scheme)
-                ast.loc.expression.source_buffer.source.chars.map.with_index do |char, i|
+                ast.source_range.source_buffer.source.chars.map.with_index do |char, i|
                   Rainbow(char).color(map[i])
                 end.join
               end
@@ -109,14 +111,7 @@ module RuboCop
             private
 
             def ruby_ast(ruby)
-              buffer = ::Parser::Source::Buffer.new('(ruby)', source: ruby)
-              ruby_parser.parse(buffer)
-            end
-
-            def ruby_parser
-              require 'parser/current'
-              builder = ::RuboCop::AST::Builder.new
-              ::Parser::CurrentRuby.new(builder)
+              ProcessedSource.new(ruby, RUBY_VERSION.to_f, '(ruby)').ast
             end
           end
 

data/lib/rubocop/ast/node_pattern/compiler/sequence_subcompiler.rb

@@ -13,8 +13,8 @@ module RuboCop
         # Doc on how this fits in the compiling process:
         #   /docs/modules/ROOT/pages/node_pattern.adoc
         #
-        # rubocop:disable Metrics/ClassLength
-        class SequenceSubcompiler < Subcompiler
+        class SequenceSubcompiler < Subcompiler # rubocop:disable Metrics/ClassLength
+          # Shift of 1 from standard Ruby indices
           DELTA = 1
           POSITIVE = :positive?.to_proc
           private_constant :POSITIVE
@@ -261,7 +261,7 @@ module RuboCop
             arities = children
                       .reverse
                       .map(&:arity_range)
-                      .map { |r| last = last.begin + r.begin..last.max + r.max }
+                      .map { |r| last = (last.begin + r.begin)..(last.max + r.max) }
                       .reverse!
             arities.push last_arity
           end
@@ -413,7 +413,6 @@ module RuboCop
             @in_sync = sub_compilers.all?(&:in_sync)
           end
         end
-        # rubocop:enable Metrics/ClassLength
       end
     end
   end

data/lib/rubocop/ast/node_pattern/compiler.rb

@@ -9,7 +9,7 @@ module RuboCop
       # Doc on how this fits in the compiling process:
       #   /docs/modules/ROOT/pages/node_pattern.adoc
       class Compiler
-        extend Forwardable
+        extend SimpleForwardable
         attr_reader :captures, :named_parameters, :positional_parameters, :binding
 
         def initialize

data/lib/rubocop/ast/node_pattern/lexer.rex.rb

@@ -2,7 +2,7 @@
 # encoding: UTF-8
 #--
 # This file is automatically generated. Do not modify it.
-# Generated by: oedipus_lex version 2.6.0.
+# Generated by: oedipus_lex version 2.6.2.
 # Source: lib/rubocop/ast/node_pattern/lexer.rex
 #++
 
@@ -70,7 +70,6 @@ class RuboCop::AST::NodePattern::LexerRex
     yield
   end
 
-
   ##
   # The current scanner class. Must be overridden in subclasses.
 

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

@@ -5,9 +5,8 @@ module RuboCop
     class NodePattern
       # Base class for AST Nodes of a `NodePattern`
       class Node < ::Parser::AST::Node
-        extend Forwardable
+        extend SimpleForwardable
         include ::RuboCop::AST::Descendence
-        using Ext::RangeMinMax
 
         MATCHES_WITHIN_SET = %i[symbol number string].to_set.freeze
         private_constant :MATCHES_WITHIN_SET
@@ -49,7 +48,7 @@ module RuboCop
           children[0]
         end
 
-        # @return [Integer] nb of captures of that node and its descendants
+        # @return [Integer] nb of captures that this node will emit
         def nb_captures
           children_nodes.sum(&:nb_captures)
         end
@@ -75,6 +74,10 @@ module RuboCop
           self.class.new(type, children, { location: location })
         end
 
+        def source_range
+          loc.expression
+        end
+
         INT_TO_RANGE = Hash.new { |h, k| h[k] = k..k }
         private_constant :INT_TO_RANGE
 
@@ -176,7 +179,7 @@ module RuboCop
         class AnyOrder < Node
           include ForbidInSeqHead
 
-          ARITIES = Hash.new { |h, k| h[k] = k - 1..Float::INFINITY }
+          ARITIES = Hash.new { |h, k| h[k] = (k - 1)..Float::INFINITY }
           private_constant :ARITIES
 
           def term_nodes
@@ -203,7 +206,7 @@ module RuboCop
           include ForbidInSeqHead
 
           def arity
-            min, max = children.map(&:arity_range).map(&:minmax).transpose.map(&:sum)
+            min, max = children.map { |child| child.arity_range.minmax }.transpose.map(&:sum)
             min == max ? min || 0 : min..max # NOTE: || 0 for empty case, where min == max == nil.
           end
 
@@ -219,7 +222,7 @@ module RuboCop
         # Node class for `{ ... }`
         class Union < Node
           def arity
-            minima, maxima = children.map(&:arity_range).map(&:minmax).transpose
+            minima, maxima = children.map { |child| child.arity_range.minmax }.transpose
             min = minima.min
             max = maxima.max
             min == max ? min : min..max
@@ -240,6 +243,12 @@ module RuboCop
 
             [with(children: new_children)]
           end
+
+          # Each child in a union must contain the same number
+          # of captures. Only one branch ends up capturing.
+          def nb_captures
+            child.nb_captures
+          end
         end
 
         # Registry

data/lib/rubocop/ast/node_pattern/parser.racc.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 #
 # DO NOT MODIFY!!!!
-# This file is automatically generated by Racc 1.5.1
-# from Racc grammar file "".
+# This file is automatically generated by Racc 1.8.1
+# from Racc grammar file "parser.y".
 #
 
 require 'racc/parser.rb'
@@ -239,6 +239,7 @@ Racc_arg = [
   racc_shift_n,
   racc_reduce_n,
   racc_use_result_var ]
+Ractor.make_shareable(Racc_arg) if defined?(Ractor)
 
 Racc_token_to_s_table = [
   "$end",
@@ -289,6 +290,7 @@ Racc_token_to_s_table = [
   "opt_rest",
   "rest",
   "arg_list" ]
+Ractor.make_shareable(Racc_token_to_s_table) if defined?(Ractor)
 
 Racc_debug_parser = false
 

data/lib/rubocop/ast/node_pattern/parser.rb

@@ -11,7 +11,7 @@ module RuboCop
       # Doc on how this fits in the compiling process:
       #   /docs/modules/ROOT/pages/node_pattern.adoc
       class Parser < Racc::Parser
-        extend Forwardable
+        extend SimpleForwardable
 
         Builder = NodePattern::Builder
         Lexer = NodePattern::Lexer

data/lib/rubocop/ast/node_pattern/with_meta.rb

@@ -48,12 +48,12 @@ module RuboCop
 
             def emit_unary_op(type, operator_t = nil, *children)
               children[-1] = children[-1].first if children[-1].is_a?(Array) # token?
-              map = source_map(children.first.loc.expression, operator_t: operator_t)
+              map = source_map(children.first.source_range, operator_t: operator_t)
               n(type, children, map)
             end
 
             def emit_list(type, begin_t, children, end_t)
-              expr = children.first.loc.expression.join(children.last.loc.expression)
+              expr = children.first.source_range.join(children.last.source_range)
               map = source_map(expr, begin_t: begin_t, end_t: end_t)
               n(type, children, map)
             end
@@ -79,8 +79,7 @@ module RuboCop
             end
 
             def join_exprs(left_expr, right_expr)
-              left_expr.loc.expression
-                       .join(right_expr.loc.expression)
+              left_expr.source_range.join(right_expr.source_range)
             end
 
             def source_map(token_or_range, begin_t: nil, end_t: nil, operator_t: nil, selector_t: nil)

data/lib/rubocop/ast/node_pattern.rb

@@ -48,7 +48,7 @@ module RuboCop
         end
       end
 
-      extend Forwardable
+      extend SimpleForwardable
       include MethodDefiner
       Invalid = Class.new(StandardError)