rubocop 1.57.1 → 1.81.6

data/lib/rubocop/cop/style/redundant_line_continuation.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Check for redundant line continuation.
+      # Checks for redundant line continuation.
       #
       # This cop marks a line continuation as redundant if removing the backslash
       # does not result in a syntax error.
@@ -69,16 +69,24 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Redundant line continuation.'
+        LINE_CONTINUATION = '\\'
+        LINE_CONTINUATION_PATTERN = /(\\\n)/.freeze
         ALLOWED_STRING_TOKENS = %i[tSTRING tSTRING_CONTENT].freeze
         ARGUMENT_TYPES = %i[
-          kFALSE kNIL kSELF kTRUE tCONSTANT tCVAR tFLOAT tGVAR tIDENTIFIER tINTEGER tIVAR
-          tLBRACK tLCURLY tLPAREN_ARG tSTRING tSTRING_BEG tSYMBOL tXSTRING_BEG
+          kDEF kDEFINED kFALSE kNIL kSELF kTRUE tAMPER tBANG tCARET tCHARACTER tCOLON3 tCONSTANT
+          tCVAR tDOT2 tDOT3 tFLOAT tGVAR tIDENTIFIER tINTEGER tIVAR tLAMBDA tLBRACK tLCURLY
+          tLPAREN_ARG tPIPE tQSYMBOLS_BEG tQWORDS_BEG tREGEXP_BEG tSTAR tSTRING tSTRING_BEG tSYMBEG
+          tSYMBOL tSYMBOLS_BEG tTILDE tUMINUS tUNARY_NUM tUPLUS tWORDS_BEG tXSTRING_BEG
         ].freeze
+        ARGUMENT_TAKING_FLOW_TOKEN_TYPES = %i[
+          tIDENTIFIER kBREAK kNEXT kRETURN kSUPER kYIELD
+        ].freeze
+        ARITHMETIC_OPERATOR_TOKENS = %i[tDIVIDE tDSTAR tMINUS tPERCENT tPLUS tSTAR2].freeze
 
         def on_new_investigation
           return unless processed_source.ast
 
-          each_match_range(processed_source.ast.source_range, /(\\\n)/) do |range|
+          each_match_range(processed_source.ast.source_range, LINE_CONTINUATION_PATTERN) do |range|
             next if require_line_continuation?(range)
             next unless redundant_line_continuation?(range)
 
@@ -86,19 +94,27 @@ module RuboCop
               corrector.remove_leading(range, 1)
             end
           end
+
+          inspect_end_of_ruby_code_line_continuation
         end
 
         private
 
         def require_line_continuation?(range)
-          !ends_with_backslash_without_comment?(range.source_line) ||
+          !ends_with_uncommented_backslash?(range) ||
             string_concatenation?(range.source_line) ||
-            start_with_arithmetic_operator?(processed_source[range.line]) ||
-            inside_string_literal_or_method_with_argument?(range)
+            start_with_arithmetic_operator?(range) ||
+            inside_string_literal_or_method_with_argument?(range) ||
+            leading_dot_method_chain_with_blank_line?(range)
         end
 
-        def ends_with_backslash_without_comment?(source_line)
-          source_line.gsub(/#.+/, '').end_with?('\\')
+        def ends_with_uncommented_backslash?(range)
+          # A line continuation always needs to be the last character on the line, which
+          # means that it is impossible to have a comment following a continuation.
+          # Therefore, if the line contains a comment, it cannot end with a continuation.
+          return false if processed_source.line_with_comment?(range.line)
+
+          range.source_line.end_with?(LINE_CONTINUATION)
         end
 
         def string_concatenation?(source_line)
@@ -106,17 +122,48 @@ module RuboCop
         end
 
         def inside_string_literal_or_method_with_argument?(range)
+          line_range = range_by_whole_lines(range)
+
           processed_source.tokens.each_cons(2).any? do |token, next_token|
-            inside_string_literal?(range, token) || method_with_argument?(token, next_token)
+            next if token.line == next_token.line
+
+            inside_string_literal?(range, token) ||
+              method_with_argument?(line_range, token, next_token)
           end
         end
 
+        def leading_dot_method_chain_with_blank_line?(range)
+          return false unless range.source_line.strip.start_with?('.', '&.')
+
+          processed_source[range.line].strip.empty?
+        end
+
         def redundant_line_continuation?(range)
-          return true unless (node = find_node_for_line(range.line))
+          return true unless (node = find_node_for_line(range.last_line))
           return false if argument_newline?(node)
 
-          source = node.parent ? node.parent.source : node.source
-          parse(source.gsub("\\\n", "\n")).valid_syntax?
+          # Check if source is still valid without the continuation
+          source = processed_source.raw_source.dup
+          source[range.begin_pos, range.length] = "\n"
+          parse(source).valid_syntax?
+        end
+
+        def inspect_end_of_ruby_code_line_continuation
+          last_line = processed_source.lines[processed_source.ast.last_line - 1]
+          return unless code_ends_with_continuation?(last_line)
+
+          last_column = last_line.length
+          line_continuation_range = range_between(last_column - 1, last_column)
+
+          add_offense(line_continuation_range) do |corrector|
+            corrector.remove_trailing(line_continuation_range, 1)
+          end
+        end
+
+        def code_ends_with_continuation?(last_line)
+          return false if processed_source.line_with_comment?(processed_source.ast.last_line)
+
+          last_line.end_with?(LINE_CONTINUATION)
         end
 
         def inside_string_literal?(range, token)
@@ -127,11 +174,16 @@ module RuboCop
         #
         #   do_something \
         #     argument
-        def method_with_argument?(current_token, next_token)
-          current_token.type == :tIDENTIFIER && ARGUMENT_TYPES.include?(next_token.type)
+        def method_with_argument?(line_range, current_token, next_token)
+          return false unless ARGUMENT_TAKING_FLOW_TOKEN_TYPES.include?(current_token.type)
+          return false unless current_token.pos.overlaps?(line_range)
+
+          ARGUMENT_TYPES.include?(next_token.type)
         end
 
         def argument_newline?(node)
+          return false if node.parenthesized_call?
+
           node = node.children.first if node.root? && node.begin_type?
 
           if argument_is_method?(node)
@@ -143,9 +195,9 @@ module RuboCop
           end
         end
 
-        def find_node_for_line(line)
+        def find_node_for_line(last_line)
           processed_source.ast.each_node do |node|
-            return node if same_line?(node, line)
+            return node if same_line?(node, last_line)
           end
         end
 
@@ -174,8 +226,9 @@ module RuboCop
           node.call_type? && !node.arguments.empty?
         end
 
-        def start_with_arithmetic_operator?(source_line)
-          %r{\A\s*[+\-*/%]}.match?(source_line)
+        def start_with_arithmetic_operator?(range)
+          line_range = processed_source.buffer.line_range(range.line + 1)
+          ARITHMETIC_OPERATOR_TOKENS.include?(processed_source.first_token_of(line_range).type)
         end
       end
     end

data/lib/rubocop/cop/style/redundant_parentheses.rb

@@ -13,18 +13,16 @@ module RuboCop
       #   # good
       #   x if y.z.nil?
       #
-      class RedundantParentheses < Base
+      class RedundantParentheses < Base # rubocop:disable Metrics/ClassLength
         include Parentheses
         extend AutoCorrector
 
-        # @!method square_brackets?(node)
-        def_node_matcher :square_brackets?, '(send {(send _recv _msg) str array hash} :[] ...)'
-
-        # @!method range_end?(node)
-        def_node_matcher :range_end?, '^^{irange erange}'
+        ALLOWED_NODE_TYPES = %i[or send splat kwsplat].freeze
 
-        # @!method method_node_and_args(node)
-        def_node_matcher :method_node_and_args, '$(call _recv _msg $...)'
+        # @!method square_brackets?(node)
+        def_node_matcher :square_brackets?, <<~PATTERN
+          (send `{(send _recv _msg) str array hash const #variable?} :[] ...)
+        PATTERN
 
         # @!method rescue?(node)
         def_node_matcher :rescue?, '{^resbody ^^resbody}'
@@ -32,9 +30,6 @@ module RuboCop
         # @!method allowed_pin_operator?(node)
         def_node_matcher :allowed_pin_operator?, '^(pin (begin !{lvar ivar cvar gvar}))'
 
-        # @!method arg_in_call_with_block?(node)
-        def_node_matcher :arg_in_call_with_block?, '^^(block (send _ _ equal?(%0) ...) ...)'
-
         def on_begin(node)
           return if !parentheses?(node) || parens_allowed?(node) || ignore_syntax?(node)
 
@@ -43,10 +38,15 @@ module RuboCop
 
         private
 
+        def variable?(node)
+          node.respond_to?(:variable?) && node.variable?
+        end
+
         def parens_allowed?(node)
           empty_parentheses?(node) ||
             first_arg_begins_with_hash_literal?(node) ||
             rescue?(node) ||
+            in_pattern_matching_in_method_argument?(node) ||
             allowed_pin_operator?(node) ||
             allowed_expression?(node)
         end
@@ -54,15 +54,15 @@ module RuboCop
         def ignore_syntax?(node)
           return false unless (parent = node.parent)
 
-          parent.while_post_type? || parent.until_post_type? ||
-            like_method_argument_parentheses?(parent)
+          parent.type?(:while_post, :until_post, :match_with_lvasgn) ||
+            like_method_argument_parentheses?(parent) || multiline_control_flow_statements?(node)
         end
 
         def allowed_expression?(node)
           allowed_ancestor?(node) ||
-            allowed_method_call?(node) ||
             allowed_multiple_expression?(node) ||
-            allowed_ternary?(node)
+            allowed_ternary?(node) ||
+            node.parent&.range_type?
         end
 
         def allowed_ancestor?(node)
@@ -70,18 +70,13 @@ module RuboCop
           keyword_ancestor?(node) && parens_required?(node)
         end
 
-        def allowed_method_call?(node)
-          # Don't flag `method (arg) { }`
-          arg_in_call_with_block?(node) && !parentheses?(node.parent)
-        end
-
         def allowed_multiple_expression?(node)
           return false if node.children.one?
 
           ancestor = node.ancestors.first
           return false unless ancestor
 
-          !ancestor.begin_type? && !ancestor.def_type? && !ancestor.block_type?
+          !ancestor.type?(:begin, :any_def, :any_block)
         end
 
         def allowed_ternary?(node)
@@ -98,10 +93,17 @@ module RuboCop
         end
 
         def like_method_argument_parentheses?(node)
-          return false if !node.send_type? && !node.super_type? && !node.yield_type?
+          return false unless node.type?(:send, :super, :yield)
 
           node.arguments.one? && !node.parenthesized? &&
-            !node.arithmetic_operation? && node.first_argument.begin_type?
+            !node.operator_method? && node.first_argument.begin_type?
+        end
+
+        def multiline_control_flow_statements?(node)
+          return false unless (parent = node.parent)
+          return false if parent.single_line?
+
+          parent.type?(:return, :next, :break)
         end
 
         def empty_parentheses?(node)
@@ -111,55 +113,122 @@ module RuboCop
 
         def first_arg_begins_with_hash_literal?(node)
           # Don't flag `method ({key: value})` or `method ({key: value}.method)`
-          method_chain_begins_with_hash_literal?(node.children.first) &&
-            first_argument?(node) &&
-            !parentheses?(node.parent)
+          hash_literal = method_chain_begins_with_hash_literal(node.children.first)
+          if (root_method = node.each_ancestor(:send).to_a.last)
+            parenthesized = root_method.parenthesized_call?
+          end
+          hash_literal && first_argument?(node) && !parentheses?(hash_literal) && !parenthesized
         end
 
-        def method_chain_begins_with_hash_literal?(node)
-          return false if node.nil?
-          return true if node.hash_type?
-          return false unless node.send_type?
+        def in_pattern_matching_in_method_argument?(begin_node)
+          return false unless begin_node.parent&.call_type?
+          return false unless (node = begin_node.children.first)
 
-          method_chain_begins_with_hash_literal?(node.children.first)
+          target_ruby_version <= 2.7 ? node.match_pattern_type? : node.match_pattern_p_type?
+        end
+
+        def method_chain_begins_with_hash_literal(node)
+          return if node.nil?
+          return node if node.hash_type?
+          return unless node.send_type?
+
+          method_chain_begins_with_hash_literal(node.children.first)
         end
 
         def check(begin_node)
           node = begin_node.children.first
 
           if (message = find_offense_message(begin_node, node))
+            if node.range_type? && !argument_of_parenthesized_method_call?(begin_node, node)
+              begin_node = begin_node.parent
+            end
+
             return offense(begin_node, message)
           end
 
-          check_send(begin_node, node) if node.call_type?
+          check_send(begin_node, node) if call_node?(node)
         end
 
-        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def find_offense_message(begin_node, node)
           return 'a keyword' if keyword_with_redundant_parentheses?(node)
-          return 'a literal' if disallowed_literal?(begin_node, node)
+          return 'a literal' if node.literal? && disallowed_literal?(begin_node, node)
           return 'a variable' if node.variable?
           return 'a constant' if node.const_type?
+          if node.assignment? && (begin_node.parent.nil? || begin_node.parent.begin_type?)
+            return 'an assignment'
+          end
+          if node.lambda_or_proc? && (node.braces? || node.send_node.lambda_literal?)
+            return 'an expression'
+          end
+          if disallowed_one_line_pattern_matching?(begin_node, node)
+            return 'a one-line pattern matching'
+          end
           return 'an interpolated expression' if interpolation?(begin_node)
+          return 'a method argument' if argument_of_parenthesized_method_call?(begin_node, node)
+          return 'a one-line rescue' if oneline_rescue_parentheses_required?(begin_node, node)
 
-          return if begin_node.chained? || !begin_node.parent.nil?
+          return if begin_node.chained?
+
+          if node.operator_keyword?
+            return if node.semantic_operator? && begin_node.parent
+            return if node.multiline? && allow_in_multiline_conditions?
+            return if ALLOWED_NODE_TYPES.include?(begin_node.parent&.type)
+            return if !node.and_type? && begin_node.parent&.and_type?
+            return if begin_node.parent&.if_type? && begin_node.parent.ternary?
 
-          if node.and_type? || node.or_type?
             'a logical expression'
           elsif node.respond_to?(:comparison_method?) && node.comparison_method?
+            return unless begin_node.parent.nil?
+
             'a comparison expression'
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         # @!method interpolation?(node)
         def_node_matcher :interpolation?, '[^begin ^^dstr]'
 
+        def argument_of_parenthesized_method_call?(begin_node, node)
+          if node.basic_conditional? || node.rescue_type? || method_call_parentheses_required?(node)
+            return false
+          end
+          return false unless (parent = begin_node.parent)
+
+          parent.call_type? && parent.parenthesized? && parent.receiver != begin_node
+        end
+
+        def oneline_rescue_parentheses_required?(begin_node, node)
+          return false unless node.rescue_type?
+          return false unless (parent = begin_node.parent)
+          return false if parent.if_type? && parent.ternary?
+          return false if parent.conditional? && parent.condition == begin_node
+
+          !parent.type?(:call, :array, :pair)
+        end
+
+        def method_call_parentheses_required?(node)
+          return false unless node.call_type?
+
+          (node.receiver.nil? || node.loc.dot) && node.arguments.any?
+        end
+
+        def allow_in_multiline_conditions?
+          !!config.for_enabled_cop('Style/ParenthesesAroundCondition')['AllowInMultilineConditions']
+        end
+
+        def call_node?(node)
+          node.call_type? || (node.any_block_type? && node.braces? && !node.lambda_or_proc?)
+        end
+
         def check_send(begin_node, node)
+          node = node.send_node if node.any_block_type?
+
           return check_unary(begin_node, node) if node.unary_operation?
 
-          return unless method_call_with_redundant_parentheses?(node)
-          return if call_chain_starts_with_int?(begin_node, node)
+          return unless method_call_with_redundant_parentheses?(begin_node, node)
+          return if call_chain_starts_with_int?(begin_node, node) ||
+                    do_end_block_in_method_chain?(begin_node, node)
 
           offense(begin_node, 'a method call')
         end
@@ -168,8 +237,7 @@ module RuboCop
           return if begin_node.chained?
 
           node = node.children.first while suspect_unary?(node)
-
-          return if node.send_type? && !method_call_with_redundant_parentheses?(node)
+          return unless method_call_with_redundant_parentheses?(begin_node, node)
 
           offense(begin_node, 'a unary operation')
         end
@@ -189,7 +257,22 @@ module RuboCop
         end
 
         def disallowed_literal?(begin_node, node)
-          node.literal? && !node.range_type? && !raised_to_power_negative_numeric?(begin_node, node)
+          if node.range_type?
+            return false unless (parent = begin_node.parent)
+
+            parent.begin_type? && parent.children.one?
+          else
+            !raised_to_power_negative_numeric?(begin_node, node)
+          end
+        end
+
+        def disallowed_one_line_pattern_matching?(begin_node, node)
+          if (parent = begin_node.parent)
+            return false if parent.any_def_type? && parent.endless?
+            return false if parent.assignment?
+          end
+
+          node.any_match_pattern_type? && node.each_ancestor.none?(&:operator_keyword?)
         end
 
         def raised_to_power_negative_numeric?(begin_node, node)
@@ -216,22 +299,33 @@ module RuboCop
           end
         end
 
-        def method_call_with_redundant_parentheses?(node)
-          return false unless node.call_type?
+        def method_call_with_redundant_parentheses?(begin_node, node)
+          return false unless node.type?(:call, :super, :yield, :defined?)
           return false if node.prefix_not?
-          return false if range_end?(node)
+          return true if singular_parenthesized_parent?(begin_node)
 
-          send_node, args = method_node_and_args(node)
+          node.arguments.empty? || parentheses?(node) || square_brackets?(node)
+        end
+
+        def singular_parenthesized_parent?(begin_node)
+          return true unless begin_node.parent
+          return false if begin_node.parent.type?(:splat, :kwsplat)
 
-          args.empty? || parentheses?(send_node) || square_brackets?(send_node)
+          parentheses?(begin_node) && begin_node.parent.children.one?
         end
 
         def only_begin_arg?(args)
-          args.one? && args.first.begin_type?
+          args.one? && args.first&.begin_type?
         end
 
         def first_argument?(node)
-          first_send_argument?(node) || first_super_argument?(node) || first_yield_argument?(node)
+          if first_send_argument?(node) ||
+             first_super_argument?(node) ||
+             first_yield_argument?(node)
+            return true
+          end
+
+          node.each_ancestor.any? { |ancestor| first_argument?(ancestor) }
         end
 
         # @!method first_send_argument?(node)
@@ -254,6 +348,12 @@ module RuboCop
           recv&.int_type? && (parent = begin_node.parent) &&
             parent.send_type? && (parent.method?(:-@) || parent.method?(:+@))
         end
+
+        def do_end_block_in_method_chain?(begin_node, node)
+          return false unless (block = node.each_descendant(:any_block).first)
+
+          block.keywords? && begin_node.each_ancestor(:call).any?
+        end
       end
     end
   end

data/lib/rubocop/cop/style/redundant_percent_q.rb

@@ -53,7 +53,7 @@ module RuboCop
           return if interpolated_quotes?(node) || allowed_percent_q?(node)
 
           add_offense(node) do |corrector|
-            delimiter = /^%Q[^"]+$|'/.match?(node.source) ? QUOTE : SINGLE_QUOTE
+            delimiter = /\A%Q[^"]+\z|'/.match?(node.source) ? QUOTE : SINGLE_QUOTE
 
             corrector.replace(node.loc.begin, delimiter)
             corrector.replace(node.loc.end, delimiter)

data/lib/rubocop/cop/style/redundant_regexp_argument.rb

@@ -33,6 +33,7 @@ module RuboCop
       #   'foo'.sub('f', 'x')
       #   'foo'.sub!('f', 'x')
       class RedundantRegexpArgument < Base
+        include StringLiteralsHelp
         extend AutoCorrector
 
         MSG = 'Use string `%<prefer>s` as argument instead of regexp `%<current>s`.'
@@ -65,18 +66,28 @@ module RuboCop
           DETERMINISTIC_REGEX.match?(regexp_node.source)
         end
 
+        # rubocop:disable Metrics/MethodLength
         def preferred_argument(regexp_node)
           new_argument = replacement(regexp_node)
 
           if new_argument.include?('"')
             new_argument.gsub!("'", "\\\\'")
+            new_argument.gsub!('\"', '"')
             quote = "'"
-          else
+          elsif new_argument.include?("\\'")
+            quote = "'"
+          elsif new_argument.include?('\'')
+            new_argument.gsub!("'", "\\\\'")
+            quote = "'"
+          elsif new_argument.include?('\\')
             quote = '"'
+          else
+            quote = enforce_double_quotes? ? '"' : "'"
           end
 
           "#{quote}#{new_argument}#{quote}"
         end
+        # rubocop:enable Metrics/MethodLength
 
         def replacement(regexp_node)
           regexp_content = regexp_node.content

data/lib/rubocop/cop/style/redundant_regexp_character_class.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for unnecessary single-element Regexp character classes.
+      # Checks for unnecessary single-element `Regexp` character classes.
       #
       # @example
       #

data/lib/rubocop/cop/style/redundant_regexp_escape.rb

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for redundant escapes inside Regexp literals.
+      # Checks for redundant escapes inside `Regexp` literals.
       #
       # @example
       #   # bad
@@ -41,6 +41,7 @@ module RuboCop
         ALLOWED_ALWAYS_ESCAPES = " \n[]^\\#".chars.freeze
         ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES = '-'.chars.freeze
         ALLOWED_OUTSIDE_CHAR_CLASS_METACHAR_ESCAPES = '.*+?{}()|$'.chars.freeze
+        INTERPOLATION_SIGILS = %w[@ $].freeze
 
         def on_regexp(node)
           each_escape(node) do |char, index, within_character_class|
@@ -64,6 +65,7 @@ module RuboCop
           # different versions of Ruby so that e.g. /\i/ != /i/
           return true if /[[:alnum:]]/.match?(char)
           return true if ALLOWED_ALWAYS_ESCAPES.include?(char) || delimiter?(node, char)
+          return true if requires_escape_to_avoid_interpolation?(node.source[index], char)
 
           if within_character_class
             ALLOWED_WITHIN_CHAR_CLASS_METACHAR_ESCAPES.include?(char) &&
@@ -95,30 +97,20 @@ module RuboCop
           delimiters.include?(char)
         end
 
-        if Gem::Version.new(Regexp::Parser::VERSION) >= Gem::Version.new('2.0')
-          def each_escape(node)
-            node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|
-              yield(expr.text[1], expr.ts, !char_class_depth.zero?) if expr.type == :escape
+        def requires_escape_to_avoid_interpolation?(char_before_escape, escaped_char)
+          # Preserve escapes after '#' that would otherwise trigger interpolation:
+          # '#@ivar', '#@@cvar', and '#$gvar'.
+          char_before_escape == '#' && INTERPOLATION_SIGILS.include?(escaped_char)
+        end
 
-              if expr.type == :set
-                char_class_depth + (event == :enter ? 1 : -1)
-              else
-                char_class_depth
-              end
-            end
-          end
-        # Please remove this `else` branch when support for regexp_parser 1.8 will be dropped.
-        # It's for compatibility with regexp_parser 1.8 and will never be maintained.
-        else
-          def each_escape(node)
-            node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|
-              yield(expr.text[1], expr.start_index, !char_class_depth.zero?) if expr.type == :escape
-
-              if expr.type == :set
-                char_class_depth + (event == :enter ? 1 : -1)
-              else
-                char_class_depth
-              end
+        def each_escape(node)
+          node.parsed_tree&.traverse&.reduce(0) do |char_class_depth, (event, expr)|
+            yield(expr.text[1], expr.ts, !char_class_depth.zero?) if expr.type == :escape
+
+            if expr.type == :set
+              char_class_depth + (event == :enter ? 1 : -1)
+            else
+              char_class_depth
             end
           end
         end

data/lib/rubocop/cop/style/redundant_return.rb

@@ -58,12 +58,12 @@ module RuboCop
 
         MSG = 'Redundant `return` detected.'
         MULTI_RETURN_MSG = 'To return multiple values, use an array.'
-        RESTRICT_ON_SEND = %i[define_method define_singleton_method].freeze
+        RESTRICT_ON_SEND = %i[define_method define_singleton_method lambda].freeze
 
         def on_send(node)
-          return unless (parent = node.parent) && parent.block_type?
+          return unless node.block_literal?
 
-          check_branch(parent.body)
+          check_branch(node.parent.body)
         end
 
         def on_def(node)
@@ -113,6 +113,7 @@ module RuboCop
           case node.type
           when :return then check_return_node(node)
           when :case   then check_case_node(node)
+          when :case_match then check_case_match_node(node)
           when :if     then check_if_node(node)
           when :rescue then check_rescue_node(node)
           when :resbody then check_resbody_node(node)
@@ -140,6 +141,11 @@ module RuboCop
           check_branch(node.else_branch)
         end
 
+        def check_case_match_node(node)
+          node.in_pattern_branches.each { |in_pattern_node| check_branch(in_pattern_node.body) }
+          check_branch(node.else_branch)
+        end
+
         def check_if_node(node)
           return if node.ternary?