rubocop 1.59.0 → 1.68.0

data/lib/rubocop/cop/lint/require_parentheses.rb

@@ -15,15 +15,11 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   if day.is? :tuesday && month == :jan
       #     # ...
       #   end
       #
-      # @example
-      #
       #   # good
-      #
       #   if day.is?(:tuesday) && month == :jan
       #     # ...
       #   end

data/lib/rubocop/cop/lint/rescue_exception.rb

@@ -8,17 +8,13 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   begin
       #     do_something
       #   rescue Exception
       #     handle_exception
       #   end
       #
-      # @example
-      #
       #   # good
-      #
       #   begin
       #     do_something
       #   rescue ArgumentError

data/lib/rubocop/cop/lint/rescue_type.rb

@@ -59,9 +59,7 @@ module RuboCop
 
         def autocorrect(corrector, node)
           rescued, _, _body = *node
-          range = Parser::Source::Range.new(node.source_range.source_buffer,
-                                            node.loc.keyword.end_pos,
-                                            rescued.source_range.end_pos)
+          range = node.loc.keyword.end.join(rescued.source_range.end)
 
           corrector.replace(range, correction(*rescued))
         end

data/lib/rubocop/cop/lint/return_in_void_context.rb

@@ -19,8 +19,6 @@ module RuboCop
       #     return 42
       #   end
       #
-      # @example
-      #
       #   # good
       #   def initialize
       #     foo

data/lib/rubocop/cop/lint/safe_navigation_chain.rb

@@ -12,15 +12,11 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   x&.foo.bar
       #   x&.foo + bar
       #   x&.foo[bar]
       #
-      # @example
-      #
       #   # good
-      #
       #   x&.foo&.bar
       #   x&.foo || bar
       class SafeNavigationChain < Base
@@ -42,6 +38,8 @@ module RuboCop
         PATTERN
 
         def on_send(node)
+          return unless require_safe_navigation?(node)
+
           bad_method?(node) do |safe_nav, method|
             return if nil_methods.include?(method) || PLUS_MINUS_METHODS.include?(node.method_name)
 
@@ -56,6 +54,13 @@ module RuboCop
 
         private
 
+        def require_safe_navigation?(node)
+          parent = node.parent
+          return true unless parent&.and_type?
+
+          parent.rhs != node || parent.lhs.receiver != parent.rhs.receiver
+        end
+
         # @param [Parser::Source::Range] offense_range
         # @param [RuboCop::AST::SendNode] send_node
         # @return [String]

data/lib/rubocop/cop/lint/safe_navigation_consistency.rb

@@ -3,88 +3,154 @@
 module RuboCop
   module Cop
     module Lint
-      # Check to make sure that if safe navigation is used for a method
-      # call in an `&&` or `||` condition that safe navigation is used for all
-      # method calls on that same object.
+      # Check to make sure that if safe navigation is used in an `&&` or `||` condition,
+      # consistent and appropriate safe navigation, without excess or deficiency,
+      # is used for all method calls on the same object.
       #
       # @example
       #   # bad
-      #   foo&.bar && foo.baz
+      #   foo&.bar && foo&.baz
       #
-      #   # bad
-      #   foo.bar || foo&.baz
+      #   # good
+      #   foo&.bar && foo.baz
       #
       #   # bad
-      #   foo&.bar && (foobar.baz || foo.baz)
+      #   foo.bar && foo&.baz
       #
       #   # good
       #   foo.bar && foo.baz
       #
+      #   # bad
+      #   foo&.bar || foo.baz
+      #
       #   # good
       #   foo&.bar || foo&.baz
       #
+      #   # bad
+      #   foo.bar || foo&.baz
+      #
       #   # good
+      #   foo.bar || foo.baz
+      #
+      #   # bad
       #   foo&.bar && (foobar.baz || foo&.baz)
       #
+      #   # good
+      #   foo&.bar && (foobar.baz || foo.baz)
+      #
       class SafeNavigationConsistency < Base
-        include IgnoredNode
         include NilMethods
         extend AutoCorrector
 
-        MSG = 'Ensure that safe navigation is used consistently inside of `&&` and `||`.'
+        USE_DOT_MSG = 'Use `.` instead of unnecessary `&.`.'
+        USE_SAFE_NAVIGATION_MSG = 'Use `&.` for consistency with safe navigation.'
+
+        def on_and(node)
+          all_operands = collect_operands(node, [])
+          operand_groups = all_operands.group_by { |operand| receiver_name_as_key(operand, +'') }
+
+          operand_groups.each_value do |grouped_operands|
+            next unless (dot_op, begin_of_rest_operands = find_consistent_parts(grouped_operands))
 
-        def on_csend(node)
-          return unless node.parent&.operator_keyword?
+            rest_operands = grouped_operands[begin_of_rest_operands..]
+            rest_operands.each do |operand|
+              next if already_appropriate_call?(operand, dot_op)
 
-          check(node)
+              register_offense(operand, dot_op)
+            end
+          end
         end
+        alias on_or on_and
+
+        private
 
-        def check(node)
-          ancestor = top_conditional_ancestor(node)
-          conditions = ancestor.conditions
-          safe_nav_receiver = node.receiver
+        def collect_operands(node, operand_nodes)
+          operand_nodes(node.lhs, operand_nodes)
+          operand_nodes(node.rhs, operand_nodes)
 
-          method_calls = conditions.select(&:send_type?)
-          unsafe_method_calls = unsafe_method_calls(method_calls, safe_nav_receiver)
+          operand_nodes
+        end
 
-          unsafe_method_calls.each do |unsafe_method_call|
-            location = location(node, unsafe_method_call)
+        def receiver_name_as_key(method, fully_receivers)
+          if method.parent.call_type?
+            receiver(method.parent, fully_receivers)
+          else
+            fully_receivers << method.receiver&.source.to_s
+          end
+        end
 
-            add_offense(location) { |corrector| autocorrect(corrector, unsafe_method_call) }
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def find_consistent_parts(grouped_operands)
+          csend_in_and, csend_in_or, send_in_and, send_in_or = most_left_indices(grouped_operands)
 
-            ignore_node(unsafe_method_call)
+          if csend_in_and
+            ['.', (send_in_and ? [send_in_and, csend_in_and].min : csend_in_and) + 1]
+          elsif send_in_or && csend_in_or
+            send_in_or < csend_in_or ? ['.', send_in_or + 1] : ['&.', csend_in_or + 1]
+          elsif send_in_and && csend_in_or && send_in_and < csend_in_or
+            ['.', csend_in_or]
           end
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-        private
+        def already_appropriate_call?(operand, dot_op)
+          return true if operand.safe_navigation? && dot_op == '&.'
 
-        def autocorrect(corrector, node)
-          return unless node.dot?
+          (operand.dot? || operand.operator_method?) && dot_op == '.'
+        end
+
+        def register_offense(operand, dot_operator)
+          offense_range = operand.operator_method? ? operand : operand.loc.dot
+          message = dot_operator == '.' ? USE_DOT_MSG : USE_SAFE_NAVIGATION_MSG
+
+          add_offense(offense_range, message: message) do |corrector|
+            next if operand.operator_method?
 
-          corrector.insert_before(node.loc.dot, '&')
+            corrector.replace(operand.loc.dot, dot_operator)
+          end
         end
 
-        def location(node, unsafe_method_call)
-          node.source_range.join(unsafe_method_call.source_range)
+        def operand_nodes(operand, operand_nodes)
+          if operand.operator_keyword?
+            collect_operands(operand, operand_nodes)
+          elsif operand.call_type?
+            operand_nodes << operand
+          end
         end
 
-        def top_conditional_ancestor(node)
-          parent = node.parent
-          unless parent &&
-                 (parent.operator_keyword? ||
-                  (parent.begin_type? && parent.parent && parent.parent.operator_keyword?))
-            return node
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def most_left_indices(grouped_operands)
+          indices = { csend_in_and: nil, csend_in_or: nil, send_in_and: nil, send_in_or: nil }
+
+          grouped_operands.each_with_index do |operand, index|
+            indices[:csend_in_and] ||= index if operand_in_and?(operand) && operand.csend_type?
+            indices[:csend_in_or] ||= index if operand_in_or?(operand) && operand.csend_type?
+            indices[:send_in_and] ||= index if operand_in_and?(operand) && !nilable?(operand)
+            indices[:send_in_or] ||= index if operand_in_or?(operand) && !nilable?(operand)
           end
 
-          top_conditional_ancestor(parent)
+          indices.values
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
-        def unsafe_method_calls(method_calls, safe_nav_receiver)
-          method_calls.select do |method_call|
-            safe_nav_receiver == method_call.receiver &&
-              !nil_methods.include?(method_call.method_name) &&
-              !ignored_node?(method_call)
-          end
+        def operand_in_and?(node)
+          return true if node.parent.and_type?
+
+          parent = node.parent.parent while node.parent.begin_type?
+
+          parent&.and_type?
+        end
+
+        def operand_in_or?(node)
+          return true if node.parent.or_type?
+
+          parent = node.parent.parent while node.parent.begin_type?
+
+          parent&.or_type?
+        end
+
+        def nilable?(node)
+          node.csend_type? || nil_methods.include?(node.method_name)
         end
       end
     end

data/lib/rubocop/cop/lint/script_permission.rb

@@ -46,14 +46,14 @@ module RuboCop
           message = format_message_from(processed_source)
 
           add_offense(comment, message: message) do
-            autocorrect(comment) if autocorrect_requested?
+            autocorrect if autocorrect_requested?
           end
         end
 
         private
 
-        def autocorrect(comment)
-          FileUtils.chmod('+x', comment.source_range.source_buffer.name)
+        def autocorrect
+          FileUtils.chmod('+x', processed_source.file_path)
         end
 
         def executable?(processed_source)

data/lib/rubocop/cop/lint/shadowed_argument.rb

@@ -123,6 +123,7 @@ module RuboCop
 
             # Shorthand assignments always use their arguments
             next false if assignment_node.shorthand_asgn?
+            next false unless assignment_node.parent
 
             node_within_block_or_conditional =
               node_within_block_or_conditional?(assignment_node.parent, argument.scope.node)

data/lib/rubocop/cop/lint/shadowing_outer_local_variable.rb

@@ -12,17 +12,16 @@ module RuboCop
       # because `Ractor` should not access outer variables.
       # eg. following style is encouraged:
       #
-      #   [source,ruby]
-      #   ----
-      #   worker_id, pipe = env
-      #   Ractor.new(worker_id, pipe) do |worker_id, pipe|
-      #   end
-      #   ----
+      # [source,ruby]
+      # ----
+      # worker_id, pipe = env
+      # Ractor.new(worker_id, pipe) do |worker_id, pipe|
+      # end
+      # ----
       #
       # @example
       #
       #   # bad
-      #
       #   def some_method
       #     foo = 1
       #
@@ -31,10 +30,7 @@ module RuboCop
       #     end
       #   end
       #
-      # @example
-      #
       #   # good
-      #
       #   def some_method
       #     foo = 1
       #

data/lib/rubocop/cop/lint/symbol_conversion.rb

@@ -141,7 +141,7 @@ module RuboCop
         end
 
         def in_percent_literal_array?(node)
-          node.parent&.array_type? && node.parent&.percent_literal?
+          node.parent&.array_type? && node.parent.percent_literal?
         end
 
         def correct_hash_key(node)

data/lib/rubocop/cop/lint/syntax.rb

@@ -17,9 +17,12 @@ module RuboCop
         private
 
         def add_offense_from_diagnostic(diagnostic, ruby_version)
-          message =
-            "#{diagnostic.message}\n(Using Ruby #{ruby_version} parser; " \
-            'configure using `TargetRubyVersion` parameter, under `AllCops`)'
+          message = if LSP.enabled?
+                      diagnostic.message
+                    else
+                      "#{diagnostic.message}\n(Using Ruby #{ruby_version} parser; " \
+                        'configure using `TargetRubyVersion` parameter, under `AllCops`)'
+                    end
           add_offense(diagnostic.location, message: message, severity: diagnostic.level)
         end
 

data/lib/rubocop/cop/lint/to_enum_arguments.rb

@@ -49,9 +49,7 @@ module RuboCop
           return unless def_node
 
           enum_conversion_call?(node) do |method_node, arguments|
-            next if method_node.call_type? &&
-                    !method_node.method?(:__method__) && !method_node.method?(:__callee__)
-            next if method_name?(method_node, def_node.method_name) &&
+            next if !method_name?(method_node, def_node.method_name) ||
                     arguments_match?(arguments, def_node)
 
             add_offense(node)

data/lib/rubocop/cop/lint/unescaped_bracket_in_regexp.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for Regexpes (both literals and via `Regexp.new` / `Regexp.compile`)
+      # that contain unescaped `]` characters.
+      #
+      # It emulates the following Ruby warning:
+      #
+      # [source,ruby]
+      # ----
+      # $ ruby -e '/abc]123/'
+      # -e:1: warning: regular expression has ']' without escape: /abc]123/
+      # ----
+      #
+      # @example
+      #   # bad
+      #   /abc]123/
+      #   %r{abc]123}
+      #   Regexp.new('abc]123')
+      #   Regexp.compile('abc]123')
+      #
+      #   # good
+      #   /abc\]123/
+      #   %r{abc\]123}
+      #   Regexp.new('abc\]123')
+      #   Regexp.compile('abc\]123')
+      #
+      class UnescapedBracketInRegexp < Base
+        extend AutoCorrector
+
+        MSG = 'Regular expression has `]` without escape.'
+        RESTRICT_ON_SEND = %i[new compile].freeze
+
+        # @!method regexp_constructor(node)
+        def_node_search :regexp_constructor, <<~PATTERN
+          (send
+            (const {nil? cbase} :Regexp) {:new :compile}
+            $str
+            ...
+          )
+        PATTERN
+
+        def on_regexp(node)
+          RuboCop::Util.silence_warnings do
+            node.parsed_tree&.each_expression do |expr|
+              detect_offenses(node, expr)
+            end
+          end
+        end
+
+        def on_send(node)
+          # Ignore nodes that contain interpolation
+          return if node.each_descendant(:dstr).any?
+
+          regexp_constructor(node) do |text|
+            Regexp::Parser.parse(text.value)&.each_expression do |expr|
+              detect_offenses(text, expr)
+            end
+          end
+        end
+
+        private
+
+        def detect_offenses(node, expr)
+          return unless expr.type?(:literal)
+
+          expr.text.scan(/(?<!\\)\]/) do
+            pos = Regexp.last_match.begin(0)
+            next if pos.zero? # if the unescaped bracket is the first character, Ruby does not warn
+
+            location = range_at_index(node, expr.ts, pos)
+
+            add_offense(location) do |corrector|
+              corrector.replace(location, '\]')
+            end
+          end
+        end
+
+        def range_at_index(node, index, offset)
+          adjustment = index + offset
+          node.loc.begin.end.adjust(begin_pos: adjustment, end_pos: adjustment + 1)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/lint/unified_integer.rb

@@ -8,14 +8,10 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   1.is_a?(Fixnum)
       #   1.is_a?(Bignum)
       #
-      # @example
-      #
       #   # good
-      #
       #   1.is_a?(Integer)
       class UnifiedInteger < Base
         extend AutoCorrector

data/lib/rubocop/cop/lint/unmodified_reduce_accumulator.rb

@@ -113,6 +113,7 @@ module RuboCop
         PATTERN
 
         def on_block(node)
+          return unless node.body
           return unless reduce_with_block?(node)
           return unless node.argument_list.length >= 2
 

data/lib/rubocop/cop/lint/unreachable_code.rb

@@ -10,14 +10,12 @@ module RuboCop
       # @example
       #
       #   # bad
-      #
       #   def some_method
       #     return
       #     do_something
       #   end
       #
       #   # bad
-      #
       #   def some_method
       #     if cond
       #       return
@@ -27,10 +25,7 @@ module RuboCop
       #     do_something
       #   end
       #
-      # @example
-      #
       #   # good
-      #
       #   def some_method
       #     do_something
       #   end
@@ -71,7 +66,7 @@ module RuboCop
             expressions.any? { |expr| flow_expression?(expr) }
           when :if
             check_if(node)
-          when :case
+          when :case, :case_match
             check_case(node)
           else
             false
@@ -89,7 +84,9 @@ module RuboCop
           return false unless else_branch
           return false unless flow_expression?(else_branch)
 
-          node.when_branches.all? { |branch| branch.body && flow_expression?(branch.body) }
+          branches = node.case_type? ? node.when_branches : node.in_pattern_branches
+
+          branches.all? { |branch| branch.body && flow_expression?(branch.body) }
         end
       end
     end

data/lib/rubocop/cop/lint/unreachable_loop.rb

@@ -160,7 +160,7 @@ module RuboCop
             break_statement && !preceded_by_continue_statement?(break_statement)
           when :if
             check_if(node)
-          when :case
+          when :case, :case_match
             check_case(node)
           else
             false
@@ -178,7 +178,13 @@ module RuboCop
           return false unless else_branch
           return false unless break_statement?(else_branch)
 
-          node.when_branches.all? { |branch| branch.body && break_statement?(branch.body) }
+          branches = if node.case_type?
+                       node.when_branches
+                     else
+                       node.in_pattern_branches
+                     end
+
+          branches.all? { |branch| branch.body && break_statement?(branch.body) }
         end
 
         def preceded_by_continue_statement?(break_statement)

data/lib/rubocop/cop/lint/uri_regexp.rb

@@ -3,29 +3,47 @@
 module RuboCop
   module Cop
     module Lint
-      # Identifies places where `URI.regexp` is obsolete and should
-      # not be used. Instead, use `URI::DEFAULT_PARSER.make_regexp`.
+      # Identifies places where `URI.regexp` is obsolete and should not be used.
+      #
+      # For Ruby 3.3 or lower, use `URI::DEFAULT_PARSER.make_regexp`.
+      # For Ruby 3.4 or higher, use `URI::RFC2396_PARSER.make_regexp`.
+      #
+      # NOTE: If you need to support both Ruby 3.3 and lower as well as Ruby 3.4 and higher,
+      # consider manually changing the code as follows:
+      #
+      # [source,ruby]
+      # ----
+      # defined?(URI::RFC2396_PARSER) ? URI::RFC2396_PARSER : URI::DEFAULT_PARSER
+      # ----
       #
       # @example
       #   # bad
       #   URI.regexp('http://example.com')
       #
-      #   # good
+      #   # good - Ruby 3.3 or lower
       #   URI::DEFAULT_PARSER.make_regexp('http://example.com')
       #
+      #   # good - Ruby 3.4 or higher
+      #   URI::RFC2396_PARSER.make_regexp('http://example.com')
+      #
       class UriRegexp < Base
         extend AutoCorrector
 
         MSG = '`%<current>s` is obsolete and should not be used. Instead, use `%<preferred>s`.'
-        URI_CONSTANTS = ['URI', '::URI'].freeze
         RESTRICT_ON_SEND = %i[regexp].freeze
 
+        # @!method uri_constant?(node)
+        def_node_matcher :uri_constant?, <<~PATTERN
+          (const {cbase nil?} :URI)
+        PATTERN
+
         def on_send(node)
-          return unless node.receiver
-          return unless URI_CONSTANTS.include?(node.receiver.source)
+          return unless uri_constant?(node.receiver)
 
+          parser = target_ruby_version >= 3.4 ? 'RFC2396_PARSER' : 'DEFAULT_PARSER'
           argument = node.first_argument ? "(#{node.first_argument.source})" : ''
-          preferred_method = "#{node.receiver.source}::DEFAULT_PARSER.make_regexp#{argument}"
+
+          preferred_method = "#{node.receiver.source}::#{parser}.make_regexp#{argument}"
           message = format(MSG, current: node.source, preferred: preferred_method)
 
           add_offense(node.loc.selector, message: message) do |corrector|