rubocop 1.45.1 → 1.50.1

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

@@ -34,6 +34,7 @@ module RuboCop
 
         def on_send(node)
           return unless regular_method_call_with_arguments?(node)
+          return if node.parenthesized?
 
           first_arg = node.first_argument.source_range
           first_arg_with_space = range_with_surrounding_space(first_arg, side: :left)
@@ -52,7 +53,6 @@ module RuboCop
         end
 
         def expect_params_after_method_name?(node)
-          return false if node.parenthesized?
           return true if no_space_between_method_name_and_first_argument?(node)
 
           first_arg = node.first_argument

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_parens.rb

@@ -91,7 +91,7 @@ module RuboCop
             if !left_parens?(token1, token2) && !right_parens?(token1, token2)
               correct_missing_space(token1, token2)
             else
-              correct_extaneus_space_between_consecutive_parens(token1, token2)
+              correct_extraneous_space_between_consecutive_parens(token1, token2)
             end
           end
         end
@@ -112,7 +112,7 @@ module RuboCop
           end
         end
 
-        def correct_extaneus_space_between_consecutive_parens(token1, token2)
+        def correct_extraneous_space_between_consecutive_parens(token1, token2)
           return if range_between(token1.end_pos, token2.begin_pos).source != ' '
 
           range = range_between(token1.end_pos, token2.begin_pos)

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

@@ -38,7 +38,7 @@ module RuboCop
           attr clone dup exists? freeze gethostbyaddr gethostbyname iterator?
         ].freeze
 
-        PREFERRED_METHDOS = {
+        PREFERRED_METHODS = {
           clone: 'to_h',
           dup: 'to_h',
           exists?: 'exist?',
@@ -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
@@ -97,11 +97,11 @@ module RuboCop
 
             "#{preferred_attr_method} #{node.first_argument.source}"
           elsif dir_env_file_const?(node.receiver)
-            prefer = PREFERRED_METHDOS[node.method_name]
+            prefer = PREFERRED_METHODS[node.method_name]
 
             prefer ? "#{node.receiver.source}.#{prefer}" : 'ENV'
           else
-            PREFERRED_METHDOS[node.method_name]
+            PREFERRED_METHODS[node.method_name]
           end
         end
 

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_match_pattern.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks that there are no repeated patterns used in `in` keywords.
+      #
+      # @example
+      #
+      #   # bad
+      #   case x
+      #   in 'first'
+      #     do_something
+      #   in 'first'
+      #     do_something_else
+      #   end
+      #
+      #   # good
+      #   case x
+      #   in 'first'
+      #     do_something
+      #   in 'second'
+      #     do_something_else
+      #   end
+      #
+      #   # bad - repeated alternate patterns with the same conditions don't depend on the order
+      #   case x
+      #   in foo | bar
+      #     first_method
+      #   in bar | foo
+      #     second_method
+      #   end
+      #
+      #   # good
+      #   case x
+      #   in foo | bar
+      #     first_method
+      #   in bar | baz
+      #     second_method
+      #   end
+      #
+      #   # bad - repeated hash patterns with the same conditions don't depend on the order
+      #   case x
+      #   in foo: a, bar: b
+      #     first_method
+      #   in bar: b, foo: a
+      #     second_method
+      #   end
+      #
+      #   # good
+      #   case x
+      #   in foo: a, bar: b
+      #     first_method
+      #   in bar: b, baz: c
+      #     second_method
+      #   end
+      #
+      #   # bad - repeated array patterns with elements in the same order
+      #   case x
+      #   in [foo, bar]
+      #     first_method
+      #   in [foo, bar]
+      #     second_method
+      #   end
+      #
+      #   # good
+      #   case x
+      #   in [foo, bar]
+      #     first_method
+      #   in [bar, foo]
+      #     second_method
+      #   end
+      #
+      #   # bad - repeated the same patterns and guard conditions
+      #   case x
+      #   in foo if bar
+      #     first_method
+      #   in foo if bar
+      #     second_method
+      #   end
+      #
+      #   # good
+      #   case x
+      #   in foo if bar
+      #     first_method
+      #   in foo if baz
+      #     second_method
+      #   end
+      #
+      class DuplicateMatchPattern < Base
+        extend TargetRubyVersion
+
+        MSG = 'Duplicate `in` pattern detected.'
+
+        minimum_target_ruby_version 2.7
+
+        def on_case_match(case_node)
+          case_node.in_pattern_branches.each_with_object(Set.new) do |in_pattern_node, previous|
+            pattern = in_pattern_node.pattern
+            next if previous.add?(pattern_identity(pattern))
+
+            add_offense(pattern)
+          end
+        end
+
+        private
+
+        def pattern_identity(pattern)
+          pattern_source = if pattern.hash_pattern_type? || pattern.match_alt_type?
+                             pattern.children.map(&:source).sort
+                           else
+                             pattern.source
+                           end
+
+          return pattern_source unless (guard = pattern.parent.children[1])
+
+          pattern_source + guard.source
+        end
+      end
+    end
+  end
+end

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) }
         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 (block_node = node.each_ancestor(:block, :numblock).first)
+            return false unless (super_class = class_new_block(block_node))
+
+            !stateless_class?(super_class)
+          elsif (class_node = node.each_ancestor(:class).first)
+            class_node.parent_class && !stateless_class?(class_node.parent_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)
@@ -131,20 +131,12 @@ module RuboCop
 
         # @!method eval_call?(node)
         def_node_matcher :eval_call?, <<~PATTERN
-          (block (send _ {:instance_eval :class_eval :module_eval} ...) ...)
+          ({block numblock} (send _ {:instance_eval :class_eval :module_eval} ...) ...)
         PATTERN
 
         # @!method exec_call?(node)
         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 ...)
-          } ...)
+          ({block numblock} (send _ {:instance_exec :class_exec :module_exec} ...) ...)
         PATTERN
       end
     end

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

@@ -31,6 +31,8 @@ module RuboCop
           return unless lhs&.casgn_type?
 
           add_offense(node.loc.operator) do |corrector|
+            next if node.each_ancestor(:def, :defs).any?
+
             corrector.replace(node.loc.operator, '=')
           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
 
@@ -281,15 +281,21 @@ module RuboCop
             .drop_while { |r| !r.equal?(range) }
             .each_cons(2)
             .map { |range1, range2| range1.end.join(range2.begin).source }
-            .all? { |intervening| /\A\s*,\s*\Z/.match?(intervening) }
+            .all?(/\A\s*,\s*\z/)
         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