rubocop 1.45.1 → 1.47.0

data/lib/rubocop/cop/layout/heredoc_argument_closing_parenthesis.rb

@@ -67,8 +67,7 @@ module RuboCop
 
           outermost_send = outermost_send_on_same_line(heredoc_arg)
           return unless outermost_send
-          return unless outermost_send.loc.end
-          return unless heredoc_arg.first_line != outermost_send.loc.end.line
+          return if end_keyword_before_closing_parentesis?(node)
           return if subsequent_closing_parentheses_in_same_line?(outermost_send)
           return if exist_argument_between_heredoc_end_and_closing_parentheses?(node)
 
@@ -160,6 +159,12 @@ module RuboCop
 
         # Closing parenthesis helpers.
 
+        def end_keyword_before_closing_parentesis?(parenthesized_send_node)
+          parenthesized_send_node.ancestors.any? do |ancestor|
+            ancestor.loc.respond_to?(:end) && ancestor.loc.end&.source == 'end'
+          end
+        end
+
         def subsequent_closing_parentheses_in_same_line?(outermost_send)
           last_arg_of_outer_send = outermost_send.last_argument
           return false unless last_arg_of_outer_send&.loc.respond_to?(:end) &&
@@ -215,6 +220,7 @@ module RuboCop
         end
 
         def exist_argument_between_heredoc_end_and_closing_parentheses?(node)
+          return true unless node.loc.end
           return false unless (heredoc_end = find_most_bottom_of_heredoc_end(node.arguments))
 
           heredoc_end < node.loc.end.begin_pos &&

data/lib/rubocop/cop/layout/heredoc_indentation.rb

@@ -115,7 +115,7 @@ module RuboCop
         end
 
         def adjust_minus(corrector, node)
-          heredoc_beginning = node.loc.expression.source
+          heredoc_beginning = node.source
           corrected = heredoc_beginning.sub(/<<-?/, '<<~')
           corrector.replace(node, corrected)
         end
@@ -139,7 +139,7 @@ module RuboCop
         end
 
         def base_indent_level(node)
-          base_line_num = node.loc.expression.line
+          base_line_num = node.source_range.line
           base_line = processed_source.lines[base_line_num - 1]
           indent_level(base_line)
         end

data/lib/rubocop/cop/layout/leading_comment_space.rb

@@ -63,7 +63,7 @@ module RuboCop
             next if gemfile_ruby_comment?(comment)
 
             add_offense(comment) do |corrector|
-              expr = comment.loc.expression
+              expr = comment.source_range
 
               corrector.insert_after(hash_mark(expr), ' ')
             end

data/lib/rubocop/cop/layout/line_continuation_leading_space.rb

@@ -51,12 +51,11 @@ module RuboCop
         private_constant :LINE_1_ENDING, :LINE_2_BEGINNING,
                          :LEADING_STYLE_OFFENSE, :TRAILING_STYLE_OFFENSE
 
-        # rubocop:disable Metrics/AbcSize
         def on_dstr(node)
           # Quick check if we possibly have line continuations.
           return unless node.source.include?('\\')
 
-          end_of_first_line = node.loc.expression.begin_pos - node.loc.expression.column
+          end_of_first_line = node.source_range.begin_pos - node.source_range.column
 
           raw_lines(node).each_cons(2) do |raw_line_one, raw_line_two|
             end_of_first_line += raw_line_one.length
@@ -70,7 +69,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         private
 

data/lib/rubocop/cop/layout/line_continuation_spacing.rb

@@ -87,22 +87,26 @@ module RuboCop
           corrector.replace(range, correction)
         end
 
-        def string_literal_ranges(ast)
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+        def ignored_literal_ranges(ast)
           # which lines start inside a string literal?
           return [] if ast.nil?
 
-          ranges = Set.new
-          ast.each_node(:str, :dstr) do |str|
-            loc = str.location
+          ast.each_node(:str, :dstr, :array).with_object(Set.new) do |literal, ranges|
+            loc = literal.location
 
-            if str.heredoc?
+            if literal.array_type?
+              next unless literal.percent_literal?
+
+              ranges << loc.expression
+            elsif literal.heredoc?
               ranges << loc.heredoc_body
             elsif loc.respond_to?(:begin) && loc.begin
               ranges << loc.expression
             end
           end
-          ranges
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def comment_ranges(comments)
           comments.map(&:loc).map(&:expression)
@@ -119,7 +123,7 @@ module RuboCop
         end
 
         def ignored_ranges
-          @ignored_ranges ||= string_literal_ranges(processed_source.ast) +
+          @ignored_ranges ||= ignored_literal_ranges(processed_source.ast) +
                               comment_ranges(processed_source.comments)
         end
 

data/lib/rubocop/cop/layout/rescue_ensure_alignment.rb

@@ -102,7 +102,7 @@ module RuboCop
               node.loc.name
             when :masgn
               mlhs_node, = *node
-              mlhs_node.loc.expression
+              mlhs_node.source_range
             else
               # It is a wrapper with access modifier.
               node.child_nodes.first.loc.name
@@ -196,7 +196,7 @@ module RuboCop
           if begin_end_alignment_style == 'start_of_line'
             start_line_range(alignment_node)
           else
-            alignment_node.loc.expression
+            alignment_node.source_range
           end
         end
 

data/lib/rubocop/cop/layout/space_in_lambda_literal.rb

@@ -64,8 +64,8 @@ module RuboCop
 
         def range_of_offense(node)
           range_between(
-            node.parent.loc.expression.begin_pos,
-            node.parent.arguments.loc.expression.end_pos
+            node.parent.source_range.begin_pos,
+            node.parent.arguments.source_range.end_pos
           )
         end
 

data/lib/rubocop/cop/layout/space_inside_block_braces.rb

@@ -146,7 +146,7 @@ module RuboCop
           if single_line && /\S$/.match?(inner)
             no_space(right_brace.begin_pos, right_brace.end_pos, 'Space missing inside }.')
           else
-            column = node.loc.expression.column
+            column = node.source_range.column
             return if multiline_block?(left_brace, right_brace) &&
                       aligned_braces?(inner, right_brace, column)
 

data/lib/rubocop/cop/layout/space_inside_percent_literal_delimiters.rb

@@ -83,7 +83,7 @@ module RuboCop
         end
 
         def body_range(node)
-          node.location.expression.with(
+          node.source_range.with(
             begin_pos: node.location.begin.end_pos,
             end_pos: node.location.end.begin_pos
           )

data/lib/rubocop/cop/layout/trailing_whitespace.rb

@@ -93,7 +93,7 @@ module RuboCop
         end
 
         def static?(heredoc)
-          heredoc.loc.expression.source.end_with? "'"
+          heredoc.source.end_with? "'"
         end
 
         def skip_heredoc?

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

@@ -68,7 +68,7 @@ module RuboCop
         PATTERN
 
         def on_const(node)
-          return if !unqualified_const?(node) || node.parent&.defined_module
+          return if !unqualified_const?(node) || node.parent&.defined_module || node.loc.nil?
 
           add_offense(node)
         end

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

@@ -70,6 +70,9 @@ module RuboCop
         def on_send(node)
           return unless debugger_method?(node)
 
+          # Basically, debugger methods are not used as a method argument without arguments.
+          return if node.arguments.empty? && node.each_ancestor(:send, :csend).any?
+
           add_offense(node)
         end
 

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

@@ -82,7 +82,7 @@ module RuboCop
 
         def offense_range(node)
           if socket_const?(node.receiver) || dir_env_file_const?(node.receiver)
-            node.loc.expression.begin.join(node.loc.selector.end)
+            node.source_range.begin.join(node.loc.selector.end)
           elsif node.method?(:attr)
             node
           else

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

@@ -100,7 +100,7 @@ module RuboCop
         end
 
         def correction_range(node)
-          range_between(node.loc.dot.end_pos, node.loc.expression.end_pos)
+          range_between(node.loc.dot.end_pos, node.source_range.end_pos)
         end
 
         def openssl_class(node)

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

@@ -187,7 +187,7 @@ module RuboCop
           if DEF_TYPES.include?(node.type)
             node.loc.keyword.join(node.loc.name)
           else
-            node.loc.expression
+            node.source_range
           end
         end
 
@@ -258,7 +258,7 @@ module RuboCop
         end
 
         def source_location(node)
-          range = node.location.expression
+          range = node.source_range
           path = smart_path(range.source_buffer.name)
           "#{path}:#{range.line}"
         end

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

@@ -86,9 +86,7 @@ module RuboCop
           # Cache by loc, not by regexp content, as content can be repeated in multiple patterns
           key = node.loc
 
-          @interpolation_locs[key] ||= node.children.select(&:begin_type?).map do |interpolation|
-            interpolation.loc.expression
-          end
+          @interpolation_locs[key] ||= node.children.select(&:begin_type?).map(&:source_range)
         end
       end
     end

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

@@ -81,7 +81,7 @@ module RuboCop
         def autocorrect(corrector, node, first_else)
           corrector.insert_after(node.loc.else, "\n")
 
-          blank_range = range_between(node.loc.else.end_pos, first_else.loc.expression.begin_pos)
+          blank_range = range_between(node.loc.else.end_pos, first_else.source_range.begin_pos)
           corrector.replace(blank_range, indentation(node))
         end
       end

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

@@ -77,7 +77,7 @@ module RuboCop
           return false unless processed_source.contains_comment?(node.source_range)
 
           line_comment = processed_source.comment_at_line(node.source_range.line)
-          !line_comment || !comment_disables_cop?(line_comment.loc.expression.source)
+          !line_comment || !comment_disables_cop?(line_comment.source)
         end
 
         def allow_empty_lambdas?

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

@@ -72,6 +72,8 @@ module RuboCop
           return if cop_config['AllowComments'] && contains_comments?(node)
 
           add_offense(node, message: format(MSG, keyword: node.keyword)) do |corrector|
+            next if node.parent&.call_type?
+
             autocorrect(corrector, node)
           end
         end
@@ -86,7 +88,7 @@ module RuboCop
 
         def remove_comments(corrector, node)
           comments_in_range(node).each do |comment|
-            range = range_by_whole_lines(comment.loc.expression, include_final_newline: true)
+            range = range_by_whole_lines(comment.source_range, include_final_newline: true)
             corrector.remove(range)
           end
         end
@@ -141,7 +143,7 @@ module RuboCop
           if empty_if_branch?(node) && else_branch?(node)
             node.source_range.with(end_pos: node.loc.else.begin_pos)
           elsif node.loc.else
-            node.source_range.with(end_pos: node.condition.loc.expression.end_pos)
+            node.source_range.with(end_pos: node.condition.source_range.end_pos)
           elsif all_branches_body_missing?(node)
             if_node = node.ancestors.detect(&:if?)
             node.source_range.with(end_pos: if_node.loc.end.end_pos)

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

@@ -25,7 +25,7 @@ module RuboCop
         def on_interpolation(begin_node)
           return unless begin_node.children.empty?
 
-          add_offense(begin_node) { |corrector| corrector.remove(begin_node.loc.expression) }
+          add_offense(begin_node) { |corrector| corrector.remove(begin_node.source_range) }
         end
       end
     end

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

@@ -83,7 +83,7 @@ module RuboCop
                           ALTERNATIVE_PROTECTED
                         end
           format(MSG, modifier: visibility,
-                      line: modifier.location.expression.line,
+                      line: modifier.source_range.line,
                       alternative: alternative)
         end
 

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

@@ -58,7 +58,7 @@ module RuboCop
           (node.str_type? && !node.loc.respond_to?(:begin)) || node.source_range.is?('__LINE__')
         end
 
-        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
         def autocorrected_value(node)
           case node.type
           when :int
@@ -71,13 +71,15 @@ module RuboCop
             autocorrected_value_for_symbol(node)
           when :array
             autocorrected_value_for_array(node)
+          when :hash
+            autocorrected_value_for_hash(node)
           when :nil
             ''
           else
             node.source.gsub('"', '\"')
           end
         end
-        # rubocop:enable Metrics/MethodLength
+        # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity
 
         def autocorrected_value_for_string(node)
           if node.source.start_with?("'", '%q')
@@ -89,9 +91,18 @@ module RuboCop
 
         def autocorrected_value_for_symbol(node)
           end_pos =
-            node.loc.end ? node.loc.end.begin_pos : node.loc.expression.end_pos
+            node.loc.end ? node.loc.end.begin_pos : node.source_range.end_pos
 
-          range_between(node.loc.begin.end_pos, end_pos).source
+          range_between(node.loc.begin.end_pos, end_pos).source.gsub('"', '\"')
+        end
+
+        def autocorrected_value_in_hash_for_symbol(node)
+          # TODO: We need to detect symbol unacceptable names more correctly
+          if / |"|'/.match?(node.value.to_s)
+            ":\\\"#{node.value.to_s.gsub('"') { '\\\\\"' }}\\\""
+          else
+            ":#{node.value}"
+          end
         end
 
         def autocorrected_value_for_array(node)
@@ -100,6 +111,37 @@ module RuboCop
           contents_range(node).source.split.to_s.gsub('"', '\"')
         end
 
+        def autocorrected_value_for_hash(node)
+          hash_string = node.children.map do |child|
+            key = autocorrected_value_in_hash(child.key)
+            value = autocorrected_value_in_hash(child.value)
+            "#{key}=>#{value}"
+          end.join(', ')
+
+          "{#{hash_string}}"
+        end
+
+        # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+        def autocorrected_value_in_hash(node)
+          case node.type
+          when :int
+            node.children.last.to_i.to_s
+          when :float
+            node.children.last.to_f.to_s
+          when :str
+            "\\\"#{node.value.to_s.gsub('"') { '\\\\\"' }}\\\""
+          when :sym
+            autocorrected_value_in_hash_for_symbol(node)
+          when :array
+            autocorrected_value_for_array(node)
+          when :hash
+            autocorrected_value_for_hash(node)
+          else
+            node.source.gsub('"', '\"')
+          end
+        end
+        # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
+
         # Does node print its own source when converted to a string?
         def prints_as_self?(node)
           node.basic_literal? ||

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

@@ -28,6 +28,21 @@ module RuboCop
       #   end
       #
       #   # bad
+      #   Employee = Class.new(Person) do
+      #     def initialize(name, salary)
+      #       @salary = salary
+      #     end
+      #   end
+      #
+      #   # good
+      #   Employee = Class.new(Person) do
+      #     def initialize(name, salary)
+      #       super(name)
+      #       @salary = salary
+      #     end
+      #   end
+      #
+      #   # bad
       #   class Parent
       #     def self.inherited(base)
       #       do_something
@@ -55,6 +70,13 @@ module RuboCop
 
         CALLBACKS = (CLASS_LIFECYCLE_CALLBACKS + METHOD_LIFECYCLE_CALLBACKS).to_set.freeze
 
+        # @!method class_new_block(node)
+        def_node_matcher :class_new_block, <<~RUBY
+          ({block numblock}
+            (send
+              (const {nil? cbase} :Class) :new $_) ...)
+        RUBY
+
         def on_def(node)
           return unless offender?(node)
 
@@ -88,8 +110,15 @@ module RuboCop
         end
 
         def inside_class_with_stateful_parent?(node)
-          class_node = node.each_ancestor(:class).first
-          class_node&.parent_class && !stateless_class?(class_node.parent_class)
+          if (class_node = node.parent) && class_node.class_type?
+            class_node.parent_class && !stateless_class?(class_node.parent_class)
+          elsif (block_node = node.each_ancestor(:block, :numblock).first)
+            return false unless (super_class = class_new_block(block_node))
+
+            !stateless_class?(super_class)
+          else
+            false
+          end
         end
 
         def stateless_class?(node)

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

@@ -120,7 +120,7 @@ module RuboCop
 
         def scoping_method_call?(child)
           child.sclass_type? || eval_call?(child) || exec_call?(child) ||
-            class_constructor?(child) || allowed_method_name?(child)
+            child.class_constructor? || allowed_method_name?(child)
         end
 
         def allowed_method_name?(node)
@@ -138,14 +138,6 @@ module RuboCop
         def_node_matcher :exec_call?, <<~PATTERN
           (block (send _ {:instance_exec :class_exec :module_exec} ...) ...)
         PATTERN
-
-        # @!method class_constructor?(node)
-        def_node_matcher :class_constructor?, <<~PATTERN
-          ({block numblock} {
-            (send (const {nil? cbase} {:Class :Module :Struct}) :new ...)
-            (send (const {nil? cbase} :Data) :define ...)
-          } ...)
-        PATTERN
       end
     end
   end

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

@@ -69,7 +69,7 @@ module RuboCop
         end
 
         def on_in_pattern(node)
-          regexp_patterns = patterns(node).select(&:regexp_type?)
+          regexp_patterns = regexp_patterns(node)
 
           @valid_ref = regexp_patterns.map { |pattern| check_regexp(pattern) }.compact.max
         end
@@ -90,16 +90,12 @@ module RuboCop
 
         private
 
-        def patterns(pattern_node)
-          pattern = pattern_node.node_parts[0]
-
-          case pattern.type
-          when :array_pattern, :match_alt
-            pattern.children
-          when :match_as
-            patterns(pattern)
-          else
+        def regexp_patterns(in_node)
+          pattern = in_node.pattern
+          if pattern.regexp_type?
             [pattern]
+          else
+            pattern.each_descendant(:regexp).to_a
           end
         end
 

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

@@ -50,7 +50,7 @@ module RuboCop
 
           add_offense(node) do |corrector|
             node.each_value do |value|
-              range = value.loc.expression
+              range = value.source_range
 
               match = range.source.match(TRAILING_QUOTE)
               corrector.remove_trailing(range, match[0].length) if match

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

@@ -41,7 +41,7 @@ module RuboCop
 
         def autocorrect(corrector, node)
           node.children.each do |child|
-            range = child.loc.expression
+            range = child.source_range
 
             corrector.remove_trailing(range, 1) if range.source.end_with?(',')
             corrector.remove_leading(range, 1) if

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

@@ -231,7 +231,7 @@ module RuboCop
           cop_names = cops.sort.map { |c| describe(c) }.join(', ')
 
           add_offense(location, message: message(cop_names)) do |corrector|
-            range = comment_range_with_surrounding_space(location, comment.loc.expression)
+            range = comment_range_with_surrounding_space(location, comment.source_range)
 
             if leave_free_comment?(comment, range)
               corrector.replace(range, ' # ')
@@ -263,8 +263,8 @@ module RuboCop
 
         def cop_range(comment, cop)
           cop = remove_department_marker(cop)
-          matching_range(comment.loc.expression, cop) ||
-            matching_range(comment.loc.expression, Badge.parse(cop).cop_name) ||
+          matching_range(comment.source_range, cop) ||
+            matching_range(comment.source_range, Badge.parse(cop).cop_name) ||
             raise("Couldn't find #{cop} in comment: #{comment.text}")
         end
 
@@ -284,12 +284,18 @@ module RuboCop
             .all? { |intervening| /\A\s*,\s*\Z/.match?(intervening) }
         end
 
+        SIMILAR_COP_NAMES_CACHE = Hash.new do |hash, cop_name|
+          hash[:all_cop_names] = Registry.global.names unless hash.key?(:all_cop_names)
+          hash[cop_name] = NameSimilarity.find_similar_name(cop_name, hash[:all_cop_names])
+        end
+        private_constant :SIMILAR_COP_NAMES_CACHE
+
         def describe(cop)
           return 'all cops' if cop == 'all'
           return "`#{remove_department_marker(cop)}` department" if department_marker?(cop)
           return "`#{cop}`" if all_cop_names.include?(cop)
 
-          similar = NameSimilarity.find_similar_name(cop, all_cop_names)
+          similar = SIMILAR_COP_NAMES_CACHE[cop]
           similar ? "`#{cop}` (did you mean `#{similar}`?)" : "`#{cop}` (unknown cop)"
         end
 

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

@@ -74,7 +74,7 @@ module RuboCop
         end
 
         def comment_start(comment)
-          comment.loc.expression.begin_pos
+          comment.source_range.begin_pos
         end
 
         def cop_name_indention(comment, name)
@@ -82,7 +82,7 @@ module RuboCop
         end
 
         def range_with_comma(comment, name)
-          source = comment.loc.expression.source
+          source = comment.source
 
           begin_pos = cop_name_indention(comment, name)
           end_pos = begin_pos + name.size
@@ -94,14 +94,14 @@ module RuboCop
 
         def range_to_remove(begin_pos, end_pos, comment)
           start = comment_start(comment)
-          source = comment.loc.expression.source
+          source = comment.source
 
           if source[begin_pos - 1] == ','
             range_with_comma_before(start, begin_pos, end_pos)
           elsif source[end_pos] == ','
             range_with_comma_after(comment, start, begin_pos, end_pos)
           else
-            range_between(start, comment.loc.expression.end_pos)
+            range_between(start, comment.source_range.end_pos)
           end
         end
 
@@ -112,7 +112,7 @@ module RuboCop
         # If the list of cops is comma-separated, but without a empty space after the comma,
         # we should **not** remove the prepending empty space, thus begin_pos += 1
         def range_with_comma_after(comment, start, begin_pos, end_pos)
-          begin_pos += 1 if comment.loc.expression.source[end_pos + 1] != ' '
+          begin_pos += 1 if comment.source[end_pos + 1] != ' '
 
           range_between(start + begin_pos, start + end_pos + 1)
         end

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

@@ -56,7 +56,7 @@ module RuboCop
             if node.parent.respond_to?(:modifier_form?) && node.parent.modifier_form?
               corrector.insert_after(node.parent, "\nend")
 
-              range = range_with_surrounding_space(node.loc.expression, side: :right)
+              range = range_with_surrounding_space(node.source_range, side: :right)
             else
               range = range_by_whole_lines(node.source_range, include_final_newline: true)
             end

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

@@ -141,7 +141,7 @@ module RuboCop
           expression = loc.expression
 
           if array_new?(variable)
-            expression = node.parent.loc.expression if node.parent.array_type?
+            expression = node.parent.source_range if node.parent.array_type?
             [expression, variable.source]
           elsif !variable.array_type?
             [expression, "[#{variable.source}]"]

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

@@ -72,7 +72,7 @@ module RuboCop
         end
 
         def with_index_range(send)
-          range_between(send.loc.selector.begin_pos, send.loc.expression.end_pos)
+          range_between(send.loc.selector.begin_pos, send.source_range.end_pos)
         end
       end
     end