rubocop 1.45.1 → 1.47.0

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

@@ -104,7 +104,7 @@ module RuboCop
         end
 
         def inline_comment?(comment)
-          !comment_line?(comment.loc.expression.source_line)
+          !comment_line?(comment.source_range.source_line)
         end
 
         def annotation_range(annotation)

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

@@ -66,7 +66,7 @@ module RuboCop
 
         def register_offense(comment, matched_keyword)
           add_offense(comment, message: format(MSG, keyword: matched_keyword)) do |corrector|
-            range = range_with_surrounding_space(comment.loc.expression, newlines: false)
+            range = range_with_surrounding_space(comment.source_range, newlines: false)
             corrector.remove(range)
 
             unless matched_keyword == 'end'
@@ -84,7 +84,7 @@ module RuboCop
         end
 
         def source_line(comment)
-          comment.location.expression.source_line
+          comment.source_range.source_line
         end
       end
     end

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

@@ -38,7 +38,7 @@ module RuboCop
           offense = offense_range(node)
           current = offense.source
 
-          if node.arguments.any?(&:percent_literal?)
+          if (use_percent_literal = node.arguments.any?(&:percent_literal?))
             if percent_literals_includes_only_basic_literals?(node)
               prefer = preferred_method(node)
               message = format(MSG, prefer: prefer, current: current)
@@ -51,7 +51,15 @@ module RuboCop
           end
 
           add_offense(offense, message: message) do |corrector|
-            corrector.replace(offense, prefer)
+            if use_percent_literal
+              corrector.replace(offense, prefer)
+            else
+              corrector.replace(node.loc.selector, 'push')
+              node.arguments.each do |argument|
+                corrector.remove(argument.loc.begin)
+                corrector.remove(argument.loc.end)
+              end
+            end
           end
         end
         # rubocop:enable Metrics

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

@@ -450,7 +450,7 @@ module RuboCop
         end
 
         def white_space_range(node, column)
-          expression = node.loc.expression
+          expression = node.source_range
           begin_pos = expression.begin_pos - (expression.column - column - 2)
 
           Parser::Source::Range.new(expression.source_buffer, begin_pos, expression.begin_pos)
@@ -458,9 +458,9 @@ module RuboCop
 
         def assignment(node)
           *_, condition = *node
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                    node.loc.expression.begin_pos,
-                                    condition.loc.expression.begin_pos)
+          Parser::Source::Range.new(node.source_range.source_buffer,
+                                    node.source_range.begin_pos,
+                                    condition.source_range.begin_pos)
         end
 
         def correct_if_branches(corrector, cop, node)
@@ -565,7 +565,7 @@ module RuboCop
           end
 
           def move_assignment_inside_condition(corrector, node)
-            column = node.loc.expression.column
+            column = node.source_range.column
             *_var, condition = *node
             assignment = assignment(node)
 
@@ -616,7 +616,7 @@ module RuboCop
           end
 
           def move_assignment_inside_condition(corrector, node)
-            column = node.loc.expression.column
+            column = node.source_range.column
             *_var, condition = *node
             assignment = assignment(node)
 

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

@@ -116,7 +116,7 @@ module RuboCop
 
         def preceding_comment_blocks(node)
           # Collect comments in the method call, but outside the heredoc
-          comments = processed_source.each_comment_in_lines(node.loc.expression.line_span)
+          comments = processed_source.each_comment_in_lines(node.source_range.line_span)
 
           comments.each_with_object({}) do |comment, hash|
             merge_adjacent_comments(comment.text, comment.loc.line, hash)

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

@@ -110,7 +110,7 @@ module RuboCop
           return if nodoc_self_or_outer_module?(node)
           return if include_statement_only?(body)
 
-          range = range_between(node.loc.expression.begin_pos, node.loc.name.end_pos)
+          range = range_between(node.source_range.begin_pos, node.loc.name.end_pos)
           message = format(MSG, type: node.type, identifier: identifier(node))
           add_offense(range, message: message)
         end

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

@@ -101,16 +101,16 @@ module RuboCop
 
         MSG = 'Missing method documentation comment.'
 
-        # @!method module_function_node?(node)
-        def_node_matcher :module_function_node?, <<~PATTERN
-          (send nil? :module_function ...)
+        # @!method modifier_node?(node)
+        def_node_matcher :modifier_node?, <<~PATTERN
+          (send nil? {:module_function :ruby2_keywords} ...)
         PATTERN
 
         def on_def(node)
           return if node.method?(:initialize)
 
           parent = node.parent
-          module_function_node?(parent) ? check(parent) : check(node)
+          modifier_node?(parent) ? check(parent) : check(node)
         end
         alias on_defs on_def
 

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

@@ -131,7 +131,7 @@ module RuboCop
         end
 
         def whole_line_expression(node)
-          range_by_whole_lines(node.loc.expression, include_final_newline: true)
+          range_by_whole_lines(node.source_range, include_final_newline: true)
         end
       end
     end

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

@@ -37,7 +37,7 @@ module RuboCop
 
         def autocorrect(corrector, node)
           block = node.parent
-          range = range_between(block.loc.begin.end_pos, node.loc.expression.end_pos)
+          range = range_between(block.loc.begin.end_pos, node.source_range.end_pos)
 
           corrector.remove(range)
         end

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

@@ -34,7 +34,7 @@ module RuboCop
 
         def autocorrect(corrector, node)
           send_node = node.parent.send_node
-          range = range_between(send_node.loc.expression.end_pos, node.loc.expression.end_pos)
+          range = range_between(send_node.source_range.end_pos, node.source_range.end_pos)
 
           corrector.remove(range)
         end

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

@@ -146,7 +146,7 @@ module RuboCop
                            actual: line_node.source,
                            expected: expected)
 
-          add_offense(line_node.loc.expression, message: message) do |corrector|
+          add_offense(line_node.source_range, message: message) do |corrector|
             corrector.replace(line_node, expected)
           end
         end
@@ -175,14 +175,14 @@ module RuboCop
         end
 
         def line_difference(line_node, code)
-          string_first_line(code) - line_node.loc.expression.first_line
+          string_first_line(code) - line_node.source_range.first_line
         end
 
         def string_first_line(str_node)
           if str_node.heredoc?
             str_node.loc.heredoc_body.first_line
           else
-            str_node.loc.expression.first_line
+            str_node.source_range.first_line
           end
         end
 
@@ -210,7 +210,7 @@ module RuboCop
         def add_offense_for_missing_line(node, code)
           register_offense(node) do |corrector|
             line_str = missing_line(node, code)
-            corrector.insert_after(node.loc.expression.end, ", #{line_str}")
+            corrector.insert_after(node.source_range.end, ", #{line_str}")
           end
         end
 

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

@@ -145,7 +145,7 @@ module RuboCop
         end
 
         def block_body_range(block_node, send_node)
-          range_between(send_node.loc.expression.end_pos, block_node.loc.end.end_pos)
+          range_between(send_node.source_range.end_pos, block_node.loc.end.end_pos)
         end
       end
     end

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

@@ -71,7 +71,7 @@ module RuboCop
             message = format(MSG, read_method: read_method(mode))
 
             add_offense(read_node, message: message) do |corrector|
-              range = range_between(node.loc.selector.begin_pos, read_node.loc.expression.end_pos)
+              range = range_between(node.loc.selector.begin_pos, read_node.source_range.end_pos)
               replacement = "#{read_method(mode)}(#{filename.source})"
 
               corrector.replace(range, replacement)

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

@@ -74,7 +74,7 @@ module RuboCop
             message = format(MSG, write_method: write_method(mode))
 
             add_offense(write_node, message: message) do |corrector|
-              range = range_between(node.loc.selector.begin_pos, write_node.loc.expression.end_pos)
+              range = range_between(node.loc.selector.begin_pos, write_node.source_range.end_pos)
               replacement = replacement(mode, filename, content, write_node)
 
               corrector.replace(range, replacement)

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

@@ -182,7 +182,7 @@ module RuboCop
 
         # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def autocorrect(corrector, node, condition, replacement, guard)
-          corrector.replace(node.loc.keyword.join(condition.loc.expression), replacement)
+          corrector.replace(node.loc.keyword.join(condition.source_range), replacement)
 
           if_branch = node.if_branch
           else_branch = node.else_branch

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

@@ -247,7 +247,7 @@ module RuboCop
         end
 
         def argument_without_space?(node)
-          node.argument? && node.loc.expression.begin_pos == node.parent.loc.selector.end_pos
+          node.argument? && node.source_range.begin_pos == node.parent.loc.selector.end_pos
         end
 
         def autocorrect_hash_rockets(corrector, pair_node)

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

@@ -11,6 +11,20 @@ module RuboCop
       # cop. The tab size is configured in the `IndentationWidth` of the
       # `Layout/IndentationStyle` cop.
       #
+      # NOTE: It is allowed when `defined?` argument has an undefined value,
+      # because using the modifier form causes the following incompatibility:
+      #
+      # [source,ruby]
+      # ----
+      # unless defined?(undefined_foo)
+      #   undefined_foo = 'default_value'
+      # end
+      # undefined_foo # => 'default_value'
+      #
+      # undefined_bar = 'default_value' unless defined?(undefined_bar)
+      # undefined_bar # => nil
+      # ----
+      #
       # @example
       #   # bad
       #   if condition
@@ -51,6 +65,8 @@ module RuboCop
         end
 
         def on_if(node)
+          return if defined_nodes(node).any? { |n| defined_argument_is_undefined?(node, n) }
+
           msg = if single_line_as_modifier?(node) && !named_capture_in_condition?(node)
                   MSG_USE_MODIFIER
                 elsif too_long_due_to_modifier?(node)
@@ -65,6 +81,24 @@ module RuboCop
 
         private
 
+        def defined_nodes(node)
+          if node.condition.defined_type?
+            [node.condition]
+          else
+            node.condition.each_descendant.select(&:defined_type?)
+          end
+        end
+
+        def defined_argument_is_undefined?(if_node, defined_node)
+          defined_argument = defined_node.first_argument
+          return false unless defined_argument.lvar_type? || defined_argument.send_type?
+
+          if_node.left_siblings.none? do |sibling|
+            sibling.respond_to?(:lvasgn_type?) && sibling.lvasgn_type? &&
+              sibling.name == defined_argument.node_parts[0]
+          end
+        end
+
         def autocorrect(corrector, node)
           replacement = if node.modifier_form?
                           last_argument = node.if_branch.last_argument if node.if_branch.send_type?

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

@@ -155,15 +155,15 @@ module RuboCop
         end
 
         def not_to_receiver(node, method_call)
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
+          Parser::Source::Range.new(node.source_range.source_buffer,
                                     node.loc.selector.begin_pos,
-                                    method_call.loc.expression.begin_pos)
+                                    method_call.source_range.begin_pos)
         end
 
         def end_parentheses(node, method_call)
-          Parser::Source::Range.new(node.loc.expression.source_buffer,
-                                    method_call.loc.expression.end_pos,
-                                    node.loc.expression.end_pos)
+          Parser::Source::Range.new(node.source_range.source_buffer,
+                                    method_call.source_range.end_pos,
+                                    node.source_range.end_pos)
         end
 
         # When comparing classes, `!(Integer < Numeric)` is not the same as

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

@@ -123,10 +123,10 @@ module RuboCop
         end
 
         def range(node)
-          buffer = node.loc.expression.source_buffer
+          buffer = node.source_range.source_buffer
           map_node = node.receiver.send_node
           begin_pos = map_node.loc.selector.begin_pos
-          end_pos = node.loc.expression.end_pos
+          end_pos = node.source_range.end_pos
 
           Parser::Source::Range.new(buffer, begin_pos, end_pos)
         end

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

@@ -226,7 +226,7 @@ module RuboCop
         end
 
         def args_end(node)
-          node.loc.expression.end
+          node.source_range.end
         end
 
         def args_parenthesized?(node)

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

@@ -48,13 +48,13 @@ module RuboCop
           when :return
             argument_range(node)
           else
-            node.loc.expression
+            node.source_range
           end
         end
 
         def argument_range(node)
-          first_argument_range = node.children.first.loc.expression
-          last_argument_range  = node.children.last.loc.expression
+          first_argument_range = node.children.first.source_range
+          last_argument_range  = node.children.last.source_range
 
           first_argument_range.join(last_argument_range)
         end

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

@@ -51,9 +51,9 @@ module RuboCop
         private
 
         def range_to_remove_for_subsequent_mixin(mixins, node)
-          range = node.loc.expression
+          range = node.source_range
           prev_mixin = mixins.each_cons(2) { |m, n| break m if n == node }
-          between = prev_mixin.loc.expression.end.join(range.begin)
+          between = prev_mixin.source_range.end.join(range.begin)
           # if separated from previous mixin with only whitespace?
           unless /\S/.match?(between.source)
             range = range.join(between) # then remove that too
@@ -75,7 +75,7 @@ module RuboCop
           message = format(MSG, mixin: send_node.method_name, suffix: 'a single statement')
 
           add_offense(send_node, message: message) do |corrector|
-            range = send_node.loc.expression
+            range = send_node.source_range
             mixins = sibling_mixins(send_node)
             if send_node == mixins.first
               correction = group_mixins(send_node, mixins)
@@ -94,7 +94,7 @@ module RuboCop
           message = format(MSG, mixin: send_node.method_name, suffix: 'separate statements')
 
           add_offense(send_node, message: message) do |corrector|
-            range = send_node.loc.expression
+            range = send_node.source_range
             correction = separate_mixins(send_node)
 
             corrector.replace(range, correction)

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

@@ -75,7 +75,7 @@ module RuboCop
         end
 
         def indentation_width(node)
-          processed_source.line_indentation(node.loc.expression.line)
+          processed_source.line_indentation(node.source_range.line)
         end
 
         def definition_width(node)

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

@@ -83,7 +83,7 @@ module RuboCop
 
         def comments_in_condition(node)
           comments_in_range(node).map do |comment|
-            "#{comment.loc.expression.source}\n"
+            "#{comment.source}\n"
           end.join
         end
 

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

@@ -112,7 +112,7 @@ module RuboCop
           if node.ternary?
             node.if_branch
           else
-            range_between(node.condition.loc.expression.end_pos, node.loc.else.begin_pos)
+            range_between(node.condition.source_range.end_pos, node.loc.else.begin_pos)
           end
         end
 

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

@@ -57,9 +57,9 @@ module RuboCop
 
         def autocorrect(corrector, node)
           range = if node.single_line?
-                    range_with_surrounding_space(node.body.loc.expression)
+                    range_with_surrounding_space(node.body.source_range)
                   else
-                    range_by_whole_lines(node.body.loc.expression, include_final_newline: true)
+                    range_by_whole_lines(node.body.source_range, include_final_newline: true)
                   end
 
           corrector.remove(range)

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

@@ -70,8 +70,8 @@ module RuboCop
         end
 
         def range_of_offense(node)
-          return node.loc.expression unless node.ternary?
-          return node.loc.expression if node.ternary? && branches_have_method?(node)
+          return node.source_range unless node.ternary?
+          return node.source_range if node.ternary? && branches_have_method?(node)
 
           range_between(node.loc.question.begin_pos, node.loc.colon.end_pos)
         end

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

@@ -33,11 +33,11 @@ module RuboCop
         private
 
         def opening_brace(node)
-          node.loc.begin.join(node.children.first.loc.expression.begin)
+          node.loc.begin.join(node.children.first.source_range.begin)
         end
 
         def closing_brace(node)
-          node.children.last.loc.expression.end.join(node.loc.end)
+          node.children.last.source_range.end.join(node.loc.end)
         end
       end
     end

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

@@ -97,7 +97,7 @@ module RuboCop
         end
 
         def autocorrect_variable_interpolation(corrector, embedded_node, node)
-          replacement = "#{embedded_node.loc.expression.source}.to_s"
+          replacement = "#{embedded_node.source}.to_s"
 
           corrector.replace(node, replacement)
         end
@@ -107,7 +107,7 @@ module RuboCop
 
           source = if require_parentheses?(embedded_var)
                      receiver = range_between(
-                       embedded_var.loc.expression.begin_pos, embedded_var.loc.selector.end_pos
+                       embedded_var.source_range.begin_pos, embedded_var.loc.selector.end_pos
                      )
                      arguments = embedded_var.arguments.map(&:source).join(', ')
 

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

@@ -153,7 +153,7 @@ module RuboCop
 
           return if node.send_type? && !method_call_with_redundant_parentheses?(node)
 
-          offense(begin_node, 'an unary operation')
+          offense(begin_node, 'a unary operation')
         end
 
         def offense(node, msg)

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

@@ -74,7 +74,7 @@ module RuboCop
 
           non_redundant =
             whitespace_in_free_space_mode?(node, class_elem) ||
-            backslash_b?(class_elem) || backslash_zero?(class_elem) ||
+            backslash_b?(class_elem) || octal_requiring_char_class?(class_elem) ||
             requires_escape_outside_char_class?(class_elem)
 
           !non_redundant
@@ -104,11 +104,10 @@ module RuboCop
           elem == '\b'
         end
 
-        def backslash_zero?(elem)
-          # See https://github.com/rubocop/rubocop/issues/11067 for details - in short "\0" != "0" -
-          # the former means an Unicode code point `"\u0000"`, the latter a number character `"0"`.
-          # Similarly "\032" means "\u001A". Other numbers starting with "\0" can also be mentioned.
-          elem == '\0'
+        def octal_requiring_char_class?(elem)
+          # The octal escapes \1 to \7 only work inside a character class
+          # because they would be a backreference outside it.
+          elem.match?(/\A\\[1-7]\z/)
         end
 
         def requires_escape_outside_char_class?(elem)

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

@@ -74,11 +74,18 @@ module RuboCop
 
         def char_class_begins_or_ends_with_escaped_hyphen?(node, index)
           # The hyphen character is allowed to be escaped within a character class
-          # but it's not necessry to escape hyphen if it's the first or last character
+          # but it's not necessary to escape hyphen if it's the first or last character
           # within the character class. This method checks if that's the case.
           # e.g. "[0-9\\-]" or "[\\-0-9]" would return true
-          contents_range(node).source[index - 1] == '[' ||
-            contents_range(node).source[index + 2] == ']'
+          content = contents_range(node).source
+
+          if content[index + 2] == ']'
+            true
+          elsif content[index - 1] == '['
+            index < 2 || content[index - 2] != '\\'
+          else
+            false
+          end
         end
 
         def delimiter?(node, char)

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

@@ -129,13 +129,13 @@ module RuboCop
         end
 
         def offense_range(sort_node, node)
-          range_between(sort_node.loc.selector.begin_pos, node.loc.expression.end_pos)
+          range_between(sort_node.loc.selector.begin_pos, node.source_range.end_pos)
         end
 
         def message(node, sorter, accessor)
           accessor_source = range_between(
             node.loc.selector.begin_pos,
-            node.loc.expression.end_pos
+            node.source_range.end_pos
           ).source
 
           format(MSG,
@@ -146,7 +146,7 @@ module RuboCop
 
         def autocorrect(corrector, node, sort_node, sorter, accessor)
           # Remove accessor, e.g. `first` or `[-1]`.
-          corrector.remove(range_between(accessor_start(node), node.loc.expression.end_pos))
+          corrector.remove(range_between(accessor_start(node), node.source_range.end_pos))
           # Replace "sort" or "sort_by" with the appropriate min/max method.
           corrector.replace(sort_node.loc.selector, suggestion(sorter, accessor, arg_value(node)))
           # Replace to avoid syntax errors when followed by a logical operator.

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

@@ -67,7 +67,7 @@ module RuboCop
           elsif begin_loc_present?(node)
             contents_range(node)
           else
-            node.loc.expression
+            node.source_range
           end
         end
 
@@ -139,7 +139,7 @@ module RuboCop
 
         def heredoc_with_disabled_interpolation?(node)
           if heredoc?(node)
-            node.loc.expression.source.end_with?("'")
+            node.source.end_with?("'")
           elsif node.parent&.dstr_type?
             heredoc_with_disabled_interpolation?(node.parent)
           else

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

@@ -125,9 +125,7 @@ module RuboCop
         end
 
         def in_same_section?(node1, node2)
-          !node1.location.expression.with(
-            end_pos: node2.location.expression.end_pos
-          ).source.include?("\n\n")
+          !node1.source_range.with(end_pos: node2.source_range.end_pos).source.include?("\n\n")
         end
       end
     end

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

@@ -105,11 +105,11 @@ module RuboCop
         private
 
         def offense_for_implicit_enforced_style(node, error)
-          range = node.loc.keyword.join(error.loc.expression)
+          range = node.loc.keyword.join(error.source_range)
 
           add_offense(range, message: MSG_IMPLICIT) do |corrector|
             error = rescue_standard_error?(node)
-            range = range_between(node.loc.keyword.end_pos, error.loc.expression.end_pos)
+            range = range_between(node.loc.keyword.end_pos, error.source_range.end_pos)
 
             corrector.remove(range)
           end

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

@@ -297,11 +297,11 @@ module RuboCop
         end
 
         def begin_range(node, method_call)
-          range_between(node.loc.expression.begin_pos, method_call.loc.expression.begin_pos)
+          range_between(node.source_range.begin_pos, method_call.source_range.begin_pos)
         end
 
         def end_range(node, method_call)
-          range_between(method_call.loc.expression.end_pos, node.loc.expression.end_pos)
+          range_between(method_call.source_range.end_pos, node.source_range.end_pos)
         end
 
         def add_safe_nav_to_all_methods_in_chain(corrector,