rubocop 0.93.1 → 1.79.2

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

@@ -3,7 +3,7 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for assignments in the conditions of
+      # Checks for assignments in the conditions of
       # if/while/until.
       #
       # `AllowSafeAssignment` option for safe assignment.
@@ -11,30 +11,36 @@ module RuboCop
       # an assignment to indicate "I know I'm using an assignment
       # as a condition. It's not a mistake."
       #
+      # @safety
+      #   This cop's autocorrection is unsafe because it assumes that
+      #   the author meant to use an assignment result as a condition.
+      #
       # @example
       #   # bad
-      #   if some_var = true
+      #   if some_var = value
       #     do_something
       #   end
       #
       #   # good
-      #   if some_var == true
+      #   if some_var == value
       #     do_something
       #   end
       #
       # @example AllowSafeAssignment: true (default)
       #   # good
-      #   if (some_var = true)
+      #   if (some_var = value)
       #     do_something
       #   end
       #
       # @example AllowSafeAssignment: false
       #   # bad
-      #   if (some_var = true)
+      #   if (some_var = value)
       #     do_something
       #   end
       #
       class AssignmentInCondition < Base
+        extend AutoCorrector
+
         include SafeAssignment
 
         MSG_WITH_SAFE_ASSIGNMENT_ALLOWED =
@@ -44,16 +50,18 @@ module RuboCop
         MSG_WITHOUT_SAFE_ASSIGNMENT_ALLOWED =
           'Use `==` if you meant to do a comparison or move the assignment ' \
           'up out of the condition.'
-        ASGN_TYPES = [:begin, *AST::Node::EQUALS_ASSIGNMENTS, :send].freeze
+        ASGN_TYPES = [:begin, *AST::Node::EQUALS_ASSIGNMENTS, :send, :csend].freeze
 
         def on_if(node)
-          return if node.condition.block_type?
-
-          traverse_node(node.condition, ASGN_TYPES) do |asgn_node|
+          traverse_node(node.condition) do |asgn_node|
             next :skip_children if skip_children?(asgn_node)
             next if allowed_construct?(asgn_node)
 
-            add_offense(asgn_node.loc.operator)
+            add_offense(asgn_node.loc.operator) do |corrector|
+              next unless safe_assignment_allowed?
+
+              corrector.wrap(asgn_node, '(', ')')
+            end
           end
         end
         alias on_while on_if
@@ -78,18 +86,20 @@ module RuboCop
         end
 
         def skip_children?(asgn_node)
-          (asgn_node.send_type? && !asgn_node.assignment_method?) ||
+          (asgn_node.call_type? && !asgn_node.assignment_method?) ||
             empty_condition?(asgn_node) ||
             (safe_assignment_allowed? && safe_assignment?(asgn_node))
         end
 
-        # each_node/visit_descendants_with_types with :skip_children
-        def traverse_node(node, types, &block)
-          result = yield node if types.include?(node.type)
+        def traverse_node(node, &block)
+          # if the node is a block, any assignments are irrelevant
+          return if node.any_block_type?
+
+          result = yield node if ASGN_TYPES.include?(node.type)
 
           return if result == :skip_children
 
-          node.each_child_node { |child| traverse_node(child, types, &block) }
+          node.each_child_node { |child| traverse_node(child, &block) }
         end
       end
     end

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

@@ -17,23 +17,21 @@ module RuboCop
       class BigDecimalNew < Base
         extend AutoCorrector
 
-        MSG = '`%<double_colon>sBigDecimal.new()` is deprecated. ' \
-              'Use `%<double_colon>sBigDecimal()` instead.'
+        MSG = '`BigDecimal.new()` is deprecated. Use `BigDecimal()` instead.'
         RESTRICT_ON_SEND = %i[new].freeze
 
+        # @!method big_decimal_new(node)
         def_node_matcher :big_decimal_new, <<~PATTERN
           (send
             (const ${nil? cbase} :BigDecimal) :new ...)
         PATTERN
 
         def on_send(node)
-          big_decimal_new(node) do |captured_value|
-            double_colon = captured_value ? '::' : ''
-            message = format(MSG, double_colon: double_colon)
-
-            add_offense(node.loc.selector, message: message) do |corrector|
+          big_decimal_new(node) do |cbase|
+            add_offense(node.loc.selector) do |corrector|
               corrector.remove(node.loc.selector)
               corrector.remove(node.loc.dot)
+              corrector.remove(cbase) if cbase
             end
           end
         end

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

@@ -3,17 +3,29 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for places where binary operator has identical operands.
+      # Checks for places where binary operator has identical operands.
       #
-      # It covers arithmetic operators: `+`, `-`, `*`, `/`, `%`, `**`;
-      # comparison operators: `==`, `===`, `=~`, `>`, `>=`, `<`, `<=`;
-      # bitwise operators: `|`, `^`, `&`, `<<`, `>>`;
+      # It covers comparison operators: `==`, `===`, `=~`, `>`, `>=`, `<`, ``<=``;
+      # bitwise operators: `|`, `^`, `&`;
       # boolean operators: `&&`, `||`
-      # and "spaceship" operator - `<=>`.
+      # and "spaceship" operator - ``<=>``.
       #
-      # This cop is marked as unsafe as it does not consider side effects when calling methods
-      # and thus can generate false positives:
+      # Simple arithmetic operations are allowed by this cop: `+`, `*`, `**`, `<<` and `>>`.
+      # Although these can be rewritten in a different way, it should not be necessary to
+      # do so. Operations such as `-` or `/` where the result will always be the same
+      # (`x - x` will always be 0; `x / x` will always be 1) are offenses, but these
+      # are covered by `Lint/NumericOperationWithConstantResult` instead.
+      #
+      # @safety
+      #   This cop is unsafe as it does not consider side effects when calling methods
+      #   and thus can generate false positives, for example:
+      #
+      #   [source,ruby]
+      #   ----
       #   if wr.take_char == '\0' && wr.take_char == '\0'
+      #     # ...
+      #   end
+      #   ----
       #
       # @example
       #   # bad
@@ -23,25 +35,29 @@ module RuboCop
       #     do_something
       #   end
       #
-      #   def childs?
+      #   def child?
       #     left_child || left_child
       #   end
       #
+      #   # good
+      #   x + x
+      #   1 << 1
+      #
       class BinaryOperatorWithIdenticalOperands < Base
         MSG = 'Binary operator `%<op>s` has identical operands.'
-        MATH_OPERATORS = %i[+ - * / % ** << >> | ^].to_set.freeze
+        RESTRICT_ON_SEND = %i[== != === <=> =~ && || > >= < <= | ^].freeze
 
         def on_send(node)
           return unless node.binary_operation?
+          return unless node.receiver == node.first_argument
 
-          lhs, operation, rhs = *node
-          return if MATH_OPERATORS.include?(node.method_name) && lhs.basic_literal?
-
-          add_offense(node, message: format(MSG, op: operation)) if lhs == rhs
+          add_offense(node, message: format(MSG, op: node.method_name))
         end
 
         def on_and(node)
-          add_offense(node, message: format(MSG, op: node.operator)) if node.lhs == node.rhs
+          return unless node.lhs == node.rhs
+
+          add_offense(node, message: format(MSG, op: node.operator))
         end
         alias on_or on_and
       end

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

@@ -3,9 +3,14 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for `:true` and `:false` symbols.
+      # Checks for `:true` and `:false` symbols.
       # In most cases it would be a typo.
       #
+      # @safety
+      #   Autocorrection is unsafe for this cop because code relying
+      #   on `:true` or `:false` symbols will break when those are
+      #   changed to actual booleans.
+      #
       # @example
       #
       #   # bad
@@ -14,8 +19,6 @@ module RuboCop
       #   # good
       #   true
       #
-      # @example
-      #
       #   # bad
       #   :false
       #
@@ -24,16 +27,16 @@ module RuboCop
       class BooleanSymbol < Base
         extend AutoCorrector
 
-        MSG = 'Symbol with a boolean name - ' \
-              'you probably meant to use `%<boolean>s`.'
+        MSG = 'Symbol with a boolean name - you probably meant to use `%<boolean>s`.'
 
+        # @!method boolean_symbol?(node)
         def_node_matcher :boolean_symbol?, '(sym {:true :false})'
 
         def on_sym(node)
           return unless boolean_symbol?(node)
 
           parent = node.parent
-          return if parent&.array_type? && parent&.percent_literal?(:symbol)
+          return if parent&.array_type? && parent.percent_literal?(:symbol)
 
           add_offense(node, message: format(MSG, boolean: node.value)) do |corrector|
             autocorrect(corrector, node)
@@ -45,7 +48,7 @@ module RuboCop
         def autocorrect(corrector, node)
           boolean_literal = node.source.delete(':')
           parent = node.parent
-          if parent&.pair_type? && node.equal?(parent.children[0])
+          if parent&.pair_type? && parent.colon? && node.equal?(parent.children[0])
             corrector.remove(parent.loc.operator)
             boolean_literal = "#{node.source} =>"
           end

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

@@ -3,51 +3,41 @@
 module RuboCop
   module Cop
     module Lint
-      # This cop checks for circular argument references in optional keyword
+      # Checks for circular argument references in optional keyword
       # arguments and optional ordinal arguments.
       #
-      # This cop mirrors a warning produced by MRI since 2.2.
+      # NOTE: This syntax was made invalid on Ruby 2.7 - Ruby 3.3 but is allowed
+      # again since Ruby 3.4.
       #
       # @example
       #
       #   # bad
-      #
       #   def bake(pie: pie)
       #     pie.heat_up
       #   end
       #
-      # @example
-      #
       #   # good
-      #
       #   def bake(pie:)
       #     pie.refrigerate
       #   end
       #
-      # @example
-      #
       #   # good
-      #
       #   def bake(pie: self.pie)
       #     pie.feed_to(user)
       #   end
       #
-      # @example
-      #
       #   # bad
-      #
       #   def cook(dry_ingredients = dry_ingredients)
       #     dry_ingredients.reduce(&:+)
       #   end
       #
-      # @example
-      #
       #   # good
-      #
       #   def cook(dry_ingredients = self.dry_ingredients)
       #     dry_ingredients.combine
       #   end
       class CircularArgumentReference < Base
+        extend TargetRubyVersion
+
         MSG = 'Circular argument reference - `%<arg_name>s`.'
 
         def on_kwoptarg(node)

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

@@ -49,25 +49,51 @@ module RuboCop
       #       const_set(:LIST, [])
       #     end
       #   end
+      #
+      # @example AllowedMethods: ['enums'] (default)
+      #   # good
+      #
+      #   # `enums` for Typed Enums via `T::Enum` in Sorbet.
+      #   # https://sorbet.org/docs/tenum
+      #   class TestEnum < T::Enum
+      #     enums do
+      #       Foo = new("foo")
+      #     end
+      #   end
+      #
       class ConstantDefinitionInBlock < Base
+        include AllowedMethods
+
         MSG = 'Do not define constants this way within a block.'
 
+        # @!method constant_assigned_in_block?(node)
         def_node_matcher :constant_assigned_in_block?, <<~PATTERN
-          ({^block_type? [^begin_type? ^^block_type?]} nil? ...)
+          ({^any_block [^begin ^^any_block]} nil? ...)
         PATTERN
 
+        # @!method module_defined_in_block?(node)
         def_node_matcher :module_defined_in_block?, <<~PATTERN
-          ({^block_type? [^begin_type? ^^block_type?]} ...)
+          ({^any_block [^begin ^^any_block]} ...)
         PATTERN
 
         def on_casgn(node)
-          add_offense(node) if constant_assigned_in_block?(node)
+          return if !constant_assigned_in_block?(node) || allowed_method?(method_name(node))
+
+          add_offense(node)
         end
 
         def on_class(node)
-          add_offense(node) if module_defined_in_block?(node)
+          return if !module_defined_in_block?(node) || allowed_method?(method_name(node))
+
+          add_offense(node)
         end
         alias on_module on_class
+
+        private
+
+        def method_name(node)
+          node.ancestors.find(&:any_block_type?).method_name
+        end
       end
     end
   end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for overwriting an exception with an exception result by use ``rescue =>``.
+      #
+      # You intended to write as `rescue StandardError`.
+      # However, you have written `rescue => StandardError`.
+      # In that case, the result of `rescue` will overwrite `StandardError`.
+      #
+      # @example
+      #
+      #   # bad
+      #   begin
+      #     something
+      #   rescue => StandardError
+      #   end
+      #
+      #   # good
+      #   begin
+      #     something
+      #   rescue StandardError
+      #   end
+      #
+      class ConstantOverwrittenInRescue < Base
+        extend AutoCorrector
+        include RangeHelp
+
+        MSG = '`%<constant>s` is overwritten by `rescue =>`.'
+
+        # @!method overwritten_constant(node)
+        def_node_matcher :overwritten_constant, <<~PATTERN
+          (resbody nil? (casgn nil? $_) nil?)
+        PATTERN
+
+        def self.autocorrect_incompatible_with
+          [Naming::RescuedExceptionsVariableName, Style::RescueStandardError]
+        end
+
+        def on_resbody(node)
+          return unless (constant = overwritten_constant(node))
+
+          add_offense(node.loc.assoc, message: format(MSG, constant: constant)) do |corrector|
+            corrector.remove(range_between(node.loc.keyword.end_pos, node.loc.assoc.end_pos))
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for constant reassignments.
+      #
+      # Emulates Ruby's runtime warning "already initialized constant X"
+      # when a constant is reassigned in the same file and namespace using the
+      # `NAME = value` syntax.
+      #
+      # The cop cannot catch all offenses, like, for example, when a constant
+      # is reassigned in another file, or when using metaprogramming (`Module#const_set`).
+      #
+      # The cop only takes into account constants assigned in a "simple" way: directly
+      # inside class/module definition, or within another constant. Other type of assignments
+      # (e.g., inside a conditional) are disregarded.
+      #
+      # The cop also tracks constant removal using `Module#remove_const` with symbol
+      # or string argument.
+      #
+      # @example
+      #   # bad
+      #   X = :foo
+      #   X = :bar
+      #
+      #   # bad
+      #   class A
+      #     X = :foo
+      #     X = :bar
+      #   end
+      #
+      #   # bad
+      #   module A
+      #     X = :foo
+      #     X = :bar
+      #   end
+      #
+      #   # good - keep only one assignment
+      #   X = :bar
+      #
+      #   class A
+      #     X = :bar
+      #   end
+      #
+      #   module A
+      #     X = :bar
+      #   end
+      #
+      #   # good - use OR assignment
+      #   X = :foo
+      #   X ||= :bar
+      #
+      #   # good - use conditional assignment
+      #   X = :foo
+      #   X = :bar unless defined?(X)
+      #
+      #   # good - remove the assigned constant first
+      #   class A
+      #     X = :foo
+      #     remove_const :X
+      #     X = :bar
+      #   end
+      #
+      class ConstantReassignment < Base
+        MSG = 'Constant `%<constant>s` is already assigned in this namespace.'
+
+        RESTRICT_ON_SEND = %i[remove_const].freeze
+
+        # @!method remove_constant(node)
+        def_node_matcher :remove_constant, <<~PATTERN
+          (send _ :remove_const
+            ({sym str} $_))
+        PATTERN
+
+        def on_casgn(node)
+          return unless fixed_constant_path?(node)
+          return unless simple_assignment?(node)
+          return if constant_names.add?(fully_qualified_constant_name(node))
+
+          add_offense(node, message: format(MSG, constant: node.name))
+        end
+
+        def on_send(node)
+          constant = remove_constant(node)
+
+          return unless constant
+
+          namespaces = ancestor_namespaces(node)
+
+          return if namespaces.none?
+
+          constant_names.delete(fully_qualified_name_for(namespaces, constant))
+        end
+
+        private
+
+        def fixed_constant_path?(node)
+          node.each_path.all? { |path| path.type?(:cbase, :const, :self) }
+        end
+
+        def simple_assignment?(node)
+          node.ancestors.all? do |ancestor|
+            return true if ancestor.type?(:module, :class)
+
+            ancestor.begin_type? || ancestor.literal? || ancestor.casgn_type? ||
+              freeze_method?(ancestor)
+          end
+        end
+
+        def freeze_method?(node)
+          node.send_type? && node.method?(:freeze)
+        end
+
+        def fully_qualified_constant_name(node)
+          if node.absolute?
+            namespace = node.namespace.const_type? ? node.namespace.source : nil
+
+            "#{namespace}::#{node.name}"
+          else
+            constant_namespaces = ancestor_namespaces(node) + constant_namespaces(node)
+
+            fully_qualified_name_for(constant_namespaces, node.name)
+          end
+        end
+
+        def fully_qualified_name_for(namespaces, constant)
+          ['', *namespaces, constant].join('::')
+        end
+
+        def constant_namespaces(node)
+          node.each_path.select(&:const_type?).map(&:short_name)
+        end
+
+        def ancestor_namespaces(node)
+          node
+            .each_ancestor(:class, :module)
+            .map { |ancestor| ancestor.identifier.short_name }
+            .reverse
+        end
+
+        def constant_names
+          @constant_names ||= Set.new
+        end
+      end
+    end
+  end
+end

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

@@ -16,6 +16,10 @@ module RuboCop
       # using the same name a namespace and a class. To avoid too many unnecessary
       # offenses, Enable this cop with `Only: [The, Constant, Names, Causing, Issues]`
       #
+      # NOTE: `Style/RedundantConstantBase` cop is disabled if this cop is enabled to prevent
+      # conflicting rules. Because it respects user configurations that want to enable
+      # this cop which is disabled by default.
+      #
       # @example
       #   # By default checks every constant
       #
@@ -58,12 +62,13 @@ module RuboCop
       class ConstantResolution < Base
         MSG = 'Fully qualify this constant to avoid possibly ambiguous resolution.'
 
+        # @!method unqualified_const?(node)
         def_node_matcher :unqualified_const?, <<~PATTERN
           (const nil? #const_name?)
         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
@@ -72,8 +77,7 @@ module RuboCop
 
         def const_name?(name)
           name = name.to_s
-          (allowed_names.empty? || allowed_names.include?(name)) &&
-            !ignored_names.include?(name)
+          (allowed_names.empty? || allowed_names.include?(name)) && !ignored_names.include?(name)
         end
 
         def allowed_names

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

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/RedundantCopDisableDirective
+# rubocop:disable Style/DoubleCopDisableDirective
+module RuboCop
+  module Cop
+    module Lint
+      # Checks that `# rubocop:enable ...` and `# rubocop:disable ...` statements
+      # are strictly formatted.
+      #
+      # A comment can be added to the directive by prefixing it with `--`.
+      #
+      # @example
+      #   # bad
+      #   # rubocop:disable Layout/LineLength Style/Encoding
+      #   #                                  ^ missing comma
+      #
+      #   # bad
+      #   # rubocop:disable
+      #
+      #   # bad
+      #   # rubocop:disable Layout/LineLength # rubocop:disable Style/Encoding
+      #
+      #   # bad
+      #   # rubocop:wrongmode Layout/LineLength
+      #
+      #   # good
+      #   # rubocop:disable Layout/LineLength
+      #
+      #   # good
+      #   # rubocop:disable Layout/LineLength, Style/Encoding
+      #
+      #   # good
+      #   # rubocop:disable all
+      #
+      #   # good
+      #   # rubocop:disable Layout/LineLength -- This is a good comment.
+      #
+      class CopDirectiveSyntax < Base
+        COMMON_MSG = 'Malformed directive comment detected.'
+
+        MISSING_MODE_NAME_MSG = 'The mode name is missing.'
+        INVALID_MODE_NAME_MSG = 'The mode name must be one of `enable`, `disable`, or `todo`.'
+        MISSING_COP_NAME_MSG = 'The cop name is missing.'
+        MALFORMED_COP_NAMES_MSG = 'Cop names must be separated by commas. ' \
+                                  'Comment in the directive must start with `--`.'
+
+        def on_new_investigation
+          processed_source.comments.each do |comment|
+            directive_comment = DirectiveComment.new(comment)
+            next unless directive_comment.start_with_marker?
+            next unless directive_comment.malformed?
+
+            message = offense_message(directive_comment)
+            add_offense(comment, message: message)
+          end
+        end
+
+        private
+
+        # rubocop:disable Metrics/MethodLength
+        def offense_message(directive_comment)
+          comment = directive_comment.comment
+          after_marker = comment.text.sub(DirectiveComment::DIRECTIVE_MARKER_REGEXP, '')
+          mode = after_marker.split(' ', 2).first
+          additional_msg = if mode.nil?
+                             MISSING_MODE_NAME_MSG
+                           elsif !DirectiveComment::AVAILABLE_MODES.include?(mode)
+                             INVALID_MODE_NAME_MSG
+                           elsif directive_comment.missing_cop_name?
+                             MISSING_COP_NAME_MSG
+                           else
+                             MALFORMED_COP_NAMES_MSG
+                           end
+
+          "#{COMMON_MSG} #{additional_msg}"
+        end
+        # rubocop:enable Metrics/MethodLength
+      end
+    end
+  end
+end
+# rubocop:enable Lint/RedundantCopDisableDirective
+# rubocop:enable Style/DoubleCopDisableDirective