rubocop 1.88.0 → 1.89.0

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

@@ -16,11 +16,14 @@ module RuboCop
       # enumerator.each { |item| item >= 2 } #=> [2, 3]
       # ----
       #
-      # NOTE: Return values in assignment method definitions such as `def foo=(arg)` are
-      # detected because they are in a void context. However, autocorrection does not remove
-      # the return value, as that would change behavior. In such cases, whether to remove
-      # the return value or rename the method to something more appropriate should be left to
-      # the user.
+      # NOTE: The last expression in an assignment method definition such as `def foo=(arg)`
+      # is not flagged. Ruby discards it (the method returns its argument), but the method can
+      # still be called directly and its return value relied upon, so flagging it would be a
+      # false positive for this lint.
+      #
+      # NOTE: A constant used in a void context is flagged but not autocorrected, since
+      # referencing a constant can trigger autoloading side effects (e.g. forcing a file to
+      # load before a monkey-patch), so removing it may change behavior.
       #
       # @example CheckForMethodsWithNoSideEffects: false (default)
       #   # bad
@@ -109,7 +112,7 @@ module RuboCop
         def check_begin(node)
           expressions = *node
           inside_each_block = node.each_ancestor(:any_block).first&.method?(:each)
-          expressions.pop if !in_void_context?(node) || inside_each_block
+          expressions.pop if !in_void_context?(node) || inside_each_block || setter_method?(node)
           expressions.each do |expr|
             check_void_op(expr) { inside_each_block }
             check_expression(expr)
@@ -212,7 +215,7 @@ module RuboCop
         end
 
         def check_nonmutating(node)
-          return unless node.type?(:send, :any_block)
+          return unless node.type?(:call, :any_block)
 
           method_name = node.method_name
           return unless NONMUTATING_METHODS.include?(method_name)
@@ -244,6 +247,10 @@ module RuboCop
           parent.respond_to?(:void_context?) && parent.void_context?
         end
 
+        def setter_method?(node)
+          node.parent&.any_def_type? && node.parent.assignment_method?
+        end
+
         def autocorrect_void_op(corrector, node)
           if node.arguments.empty?
             corrector.replace(node, node.receiver.source)
@@ -258,6 +265,10 @@ module RuboCop
         end
 
         def autocorrect_void_expression(corrector, node)
+          # Referencing a constant can trigger autoloading side effects (e.g. forcing a file
+          # to load before a monkey-patch), so removing it may change behavior. Flag but don't
+          # autocorrect, leaving it to the user.
+          return if node.const_type? && !node.special_keyword?
           return if node.parent.type?(:if, :case, :when, :case_match, :in_pattern)
           return if (def_node = node.each_ancestor(:any_def).first) && def_node.assignment_method?
 
@@ -265,7 +276,7 @@ module RuboCop
         end
 
         def autocorrect_nonmutating_send(corrector, node, suggestion)
-          send_node = if node.send_type?
+          send_node = if node.call_type?
                         node
                       else
                         node.send_node

data/lib/rubocop/cop/lint.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Cops for the `Lint` department. The department's cops are registered for lazy loading
+    # and their files are loaded on demand.
+    module Lint
+      extend LazyLoader
+
+      register_cop :AmbiguousAssignment, "#{__dir__}/lint/ambiguous_assignment"
+      register_cop :AmbiguousBlockAssociation, "#{__dir__}/lint/ambiguous_block_association"
+      register_cop :AmbiguousOperator, "#{__dir__}/lint/ambiguous_operator"
+      register_cop :AmbiguousOperatorPrecedence, "#{__dir__}/lint/ambiguous_operator_precedence"
+      register_cop :AmbiguousRange, "#{__dir__}/lint/ambiguous_range"
+      register_cop :AmbiguousRegexpLiteral, "#{__dir__}/lint/ambiguous_regexp_literal"
+      register_cop :ArrayLiteralInRegexp, "#{__dir__}/lint/array_literal_in_regexp"
+      register_cop :AssignmentInCondition, "#{__dir__}/lint/assignment_in_condition"
+      register_cop :BigDecimalNew, "#{__dir__}/lint/big_decimal_new"
+      register_cop :BinaryOperatorWithIdenticalOperands, "#{__dir__}/lint/binary_operator_with_identical_operands"
+      register_cop :BooleanSymbol, "#{__dir__}/lint/boolean_symbol"
+      register_cop :CircularArgumentReference, "#{__dir__}/lint/circular_argument_reference"
+      register_cop :ConstantDefinitionInBlock, "#{__dir__}/lint/constant_definition_in_block"
+      register_cop :ConstantOverwrittenInRescue, "#{__dir__}/lint/constant_overwritten_in_rescue"
+      register_cop :ConstantReassignment, "#{__dir__}/lint/constant_reassignment"
+      register_cop :ConstantResolution, "#{__dir__}/lint/constant_resolution"
+      register_cop :CopDirectiveSyntax, "#{__dir__}/lint/cop_directive_syntax"
+      register_cop :DataDefineOverride, "#{__dir__}/lint/data_define_override"
+      register_cop :Debugger, "#{__dir__}/lint/debugger"
+      register_cop :DeprecatedClassMethods, "#{__dir__}/lint/deprecated_class_methods"
+      register_cop :DeprecatedConstants, "#{__dir__}/lint/deprecated_constants"
+      register_cop :DeprecatedOpenSSLConstant, "#{__dir__}/lint/deprecated_open_ssl_constant"
+      register_cop :DeprecatedReference, "#{__dir__}/lint/deprecated_reference"
+      register_cop :DisjunctiveAssignmentInConstructor, "#{__dir__}/lint/disjunctive_assignment_in_constructor"
+      register_cop :DuplicateBranch, "#{__dir__}/lint/duplicate_branch"
+      register_cop :DuplicateCaseCondition, "#{__dir__}/lint/duplicate_case_condition"
+      register_cop :DuplicateElsifCondition, "#{__dir__}/lint/duplicate_elsif_condition"
+      register_cop :DuplicateHashKey, "#{__dir__}/lint/duplicate_hash_key"
+      register_cop :DuplicateMagicComment, "#{__dir__}/lint/duplicate_magic_comment"
+      register_cop :DuplicateMatchPattern, "#{__dir__}/lint/duplicate_match_pattern"
+      register_cop :DuplicateMethods, "#{__dir__}/lint/duplicate_methods"
+      register_cop :DuplicateRegexpCharacterClassElement, "#{__dir__}/lint/duplicate_regexp_character_class_element"
+      register_cop :DuplicateRequire, "#{__dir__}/lint/duplicate_require"
+      register_cop :DuplicateRescueException, "#{__dir__}/lint/duplicate_rescue_exception"
+      register_cop :DuplicateSetElement, "#{__dir__}/lint/duplicate_set_element"
+      register_cop :EachWithObjectArgument, "#{__dir__}/lint/each_with_object_argument"
+      register_cop :ElseLayout, "#{__dir__}/lint/else_layout"
+      register_cop :EmptyBlock, "#{__dir__}/lint/empty_block"
+      register_cop :EmptyClass, "#{__dir__}/lint/empty_class"
+      register_cop :EmptyConditionalBody, "#{__dir__}/lint/empty_conditional_body"
+      register_cop :EmptyEnsure, "#{__dir__}/lint/empty_ensure"
+      register_cop :EmptyExpression, "#{__dir__}/lint/empty_expression"
+      register_cop :EmptyFile, "#{__dir__}/lint/empty_file"
+      register_cop :EmptyInPattern, "#{__dir__}/lint/empty_in_pattern"
+      register_cop :EmptyInterpolation, "#{__dir__}/lint/empty_interpolation"
+      register_cop :EmptyWhen, "#{__dir__}/lint/empty_when"
+      register_cop :EnsureReturn, "#{__dir__}/lint/ensure_return"
+      register_cop :SharedMutableDefault, "#{__dir__}/lint/shared_mutable_default"
+      register_cop :ErbNewArguments, "#{__dir__}/lint/erb_new_arguments"
+      register_cop :FlipFlop, "#{__dir__}/lint/flip_flop"
+      register_cop :FloatComparison, "#{__dir__}/lint/float_comparison"
+      register_cop :FloatOutOfRange, "#{__dir__}/lint/float_out_of_range"
+      register_cop :FormatParameterMismatch, "#{__dir__}/lint/format_parameter_mismatch"
+      register_cop :HashCompareByIdentity, "#{__dir__}/lint/hash_compare_by_identity"
+      register_cop :HashNewWithKeywordArgumentsAsDefault, "#{__dir__}/lint/hash_new_with_keyword_arguments_as_default"
+      register_cop :HeredocMethodCallPosition, "#{__dir__}/lint/heredoc_method_call_position"
+      register_cop :IdentityComparison, "#{__dir__}/lint/identity_comparison"
+      register_cop :ImplicitStringConcatenation, "#{__dir__}/lint/implicit_string_concatenation"
+      register_cop :IncompatibleIoSelectWithFiberScheduler, "#{__dir__}/lint/incompatible_io_select_with_fiber_scheduler"
+      register_cop :IneffectiveAccessModifier, "#{__dir__}/lint/ineffective_access_modifier"
+      register_cop :InheritException, "#{__dir__}/lint/inherit_exception"
+      register_cop :InterpolationCheck, "#{__dir__}/lint/interpolation_check"
+      register_cop :ItWithoutArgumentsInBlock, "#{__dir__}/lint/it_without_arguments_in_block"
+      register_cop :LambdaWithoutLiteralBlock, "#{__dir__}/lint/lambda_without_literal_block"
+      register_cop :LiteralAsCondition, "#{__dir__}/lint/literal_as_condition"
+      register_cop :LiteralAssignmentInCondition, "#{__dir__}/lint/literal_assignment_in_condition"
+      register_cop :LiteralInInterpolation, "#{__dir__}/lint/literal_in_interpolation"
+      register_cop :Loop, "#{__dir__}/lint/loop"
+      register_cop :MissingCopEnableDirective, "#{__dir__}/lint/missing_cop_enable_directive"
+      register_cop :MissingSuper, "#{__dir__}/lint/missing_super"
+      register_cop :MixedCaseRange, "#{__dir__}/lint/mixed_case_range"
+      register_cop :MixedRegexpCaptureTypes, "#{__dir__}/lint/mixed_regexp_capture_types"
+      register_cop :MultipleComparison, "#{__dir__}/lint/multiple_comparison"
+      register_cop :NameTypo, "#{__dir__}/lint/name_typo"
+      register_cop :NestedMethodDefinition, "#{__dir__}/lint/nested_method_definition"
+      register_cop :NestedPercentLiteral, "#{__dir__}/lint/nested_percent_literal"
+      register_cop :NextWithoutAccumulator, "#{__dir__}/lint/next_without_accumulator"
+      register_cop :NoReturnInBeginEndBlocks, "#{__dir__}/lint/no_return_in_begin_end_blocks"
+      register_cop :NonAtomicFileOperation, "#{__dir__}/lint/non_atomic_file_operation"
+      register_cop :NonDeterministicRequireOrder, "#{__dir__}/lint/non_deterministic_require_order"
+      register_cop :NonLocalExitFromIterator, "#{__dir__}/lint/non_local_exit_from_iterator"
+      register_cop :NumberConversion, "#{__dir__}/lint/number_conversion"
+      register_cop :NumberedParameterAssignment, "#{__dir__}/lint/numbered_parameter_assignment"
+      register_cop :NumericOperationWithConstantResult, "#{__dir__}/lint/numeric_operation_with_constant_result"
+      register_cop :OrAssignmentToConstant, "#{__dir__}/lint/or_assignment_to_constant"
+      register_cop :OrderedMagicComments, "#{__dir__}/lint/ordered_magic_comments"
+      register_cop :OutOfRangeRegexpRef, "#{__dir__}/lint/out_of_range_regexp_ref"
+      register_cop :ParenthesesAsGroupedExpression, "#{__dir__}/lint/parentheses_as_grouped_expression"
+      register_cop :PercentStringArray, "#{__dir__}/lint/percent_string_array"
+      register_cop :PercentSymbolArray, "#{__dir__}/lint/percent_symbol_array"
+      register_cop :RaiseException, "#{__dir__}/lint/raise_exception"
+      register_cop :RandOne, "#{__dir__}/lint/rand_one"
+      register_cop :RedundantCopDisableDirective, "#{__dir__}/lint/redundant_cop_disable_directive"
+      register_cop :RedundantCopEnableDirective, "#{__dir__}/lint/redundant_cop_enable_directive"
+      register_cop :RedundantDirGlobSort, "#{__dir__}/lint/redundant_dir_glob_sort"
+      register_cop :RedundantRegexpQuantifiers, "#{__dir__}/lint/redundant_regexp_quantifiers"
+      register_cop :RedundantRequireStatement, "#{__dir__}/lint/redundant_require_statement"
+      register_cop :RedundantSafeNavigation, "#{__dir__}/lint/redundant_safe_navigation"
+      register_cop :RedundantSplatExpansion, "#{__dir__}/lint/redundant_splat_expansion"
+      register_cop :RedundantStringCoercion, "#{__dir__}/lint/redundant_string_coercion"
+      register_cop :RedundantTypeConversion, "#{__dir__}/lint/redundant_type_conversion"
+      register_cop :RedundantWithIndex, "#{__dir__}/lint/redundant_with_index"
+      register_cop :RedundantWithObject, "#{__dir__}/lint/redundant_with_object"
+      register_cop :RefinementImportMethods, "#{__dir__}/lint/refinement_import_methods"
+      register_cop :RegexpAsCondition, "#{__dir__}/lint/regexp_as_condition"
+      register_cop :RequireParentheses, "#{__dir__}/lint/require_parentheses"
+      register_cop :RequireRangeParentheses, "#{__dir__}/lint/require_range_parentheses"
+      register_cop :RequireRelativeSelfPath, "#{__dir__}/lint/require_relative_self_path"
+      register_cop :RescueException, "#{__dir__}/lint/rescue_exception"
+      register_cop :RescueType, "#{__dir__}/lint/rescue_type"
+      register_cop :ReturnInVoidContext, "#{__dir__}/lint/return_in_void_context"
+      register_cop :SafeNavigationConsistency, "#{__dir__}/lint/safe_navigation_consistency"
+      register_cop :SafeNavigationChain, "#{__dir__}/lint/safe_navigation_chain"
+      register_cop :SafeNavigationWithEmpty, "#{__dir__}/lint/safe_navigation_with_empty"
+      register_cop :ScriptPermission, "#{__dir__}/lint/script_permission"
+      register_cop :SelfAssignment, "#{__dir__}/lint/self_assignment"
+      register_cop :SendWithMixinArgument, "#{__dir__}/lint/send_with_mixin_argument"
+      register_cop :ShadowedArgument, "#{__dir__}/lint/shadowed_argument"
+      register_cop :ShadowedException, "#{__dir__}/lint/shadowed_exception"
+      register_cop :ShadowingOuterLocalVariable, "#{__dir__}/lint/shadowing_outer_local_variable"
+      register_cop :StructNewOverride, "#{__dir__}/lint/struct_new_override"
+      register_cop :SuppressedException, "#{__dir__}/lint/suppressed_exception"
+      register_cop :SuppressedExceptionInNumberConversion, "#{__dir__}/lint/suppressed_exception_in_number_conversion"
+      register_cop :SymbolConversion, "#{__dir__}/lint/symbol_conversion"
+      register_cop :Syntax, "#{__dir__}/lint/syntax"
+      register_cop :ToEnumArguments, "#{__dir__}/lint/to_enum_arguments"
+      register_cop :ToJSON, "#{__dir__}/lint/to_json"
+      register_cop :TopLevelReturnWithArgument, "#{__dir__}/lint/top_level_return_with_argument"
+      register_cop :TrailingCommaInAttributeDeclaration, "#{__dir__}/lint/trailing_comma_in_attribute_declaration"
+      register_cop :TripleQuotes, "#{__dir__}/lint/triple_quotes"
+      register_cop :UnderscorePrefixedVariableName, "#{__dir__}/lint/underscore_prefixed_variable_name"
+      register_cop :UnescapedBracketInRegexp, "#{__dir__}/lint/unescaped_bracket_in_regexp"
+      register_cop :UnexpectedBlockArity, "#{__dir__}/lint/unexpected_block_arity"
+      register_cop :UnifiedInteger, "#{__dir__}/lint/unified_integer"
+      register_cop :UnmodifiedReduceAccumulator, "#{__dir__}/lint/unmodified_reduce_accumulator"
+      register_cop :UnreachableCode, "#{__dir__}/lint/unreachable_code"
+      register_cop :UnreachableLoop, "#{__dir__}/lint/unreachable_loop"
+      register_cop :UnreachablePatternBranch, "#{__dir__}/lint/unreachable_pattern_branch"
+      register_cop :UnusedBlockArgument, "#{__dir__}/lint/unused_block_argument"
+      register_cop :UnusedMethodArgument, "#{__dir__}/lint/unused_method_argument"
+      register_cop :UnusedPrivateMethod, "#{__dir__}/lint/unused_private_method"
+      register_cop :UriEscapeUnescape, "#{__dir__}/lint/uri_escape_unescape"
+      register_cop :UriRegexp, "#{__dir__}/lint/uri_regexp"
+      register_cop :UselessAccessModifier, "#{__dir__}/lint/useless_access_modifier"
+      register_cop :UselessAssignment, "#{__dir__}/lint/useless_assignment"
+      register_cop :UselessConstantScoping, "#{__dir__}/lint/useless_constant_scoping"
+      register_cop :UselessDefaultValueArgument, "#{__dir__}/lint/useless_default_value_argument"
+      register_cop :UselessDefined, "#{__dir__}/lint/useless_defined"
+      register_cop :UselessElseWithoutRescue, "#{__dir__}/lint/useless_else_without_rescue"
+      register_cop :UselessMethodDefinition, "#{__dir__}/lint/useless_method_definition"
+      register_cop :UselessNumericOperation, "#{__dir__}/lint/useless_numeric_operation"
+      register_cop :UselessOr, "#{__dir__}/lint/useless_or"
+      register_cop :UselessRescue, "#{__dir__}/lint/useless_rescue"
+      register_cop :UselessRuby2Keywords, "#{__dir__}/lint/useless_ruby2_keywords"
+      register_cop :UselessSetterCall, "#{__dir__}/lint/useless_setter_call"
+      register_cop :UselessTimes, "#{__dir__}/lint/useless_times"
+      register_cop :Void, "#{__dir__}/lint/void"
+
+      autoload :UnusedArgument, "#{__dir__}/mixin/unused_argument"
+
+      # Utility classes for `Lint` department cops.
+      module Utils
+        autoload :NilReceiverChecker, "#{__dir__}/lint/utils/nil_receiver_checker"
+      end
+    end
+  end
+end

data/lib/rubocop/cop/metrics/method_length.rb

@@ -58,7 +58,7 @@ module RuboCop
           return unless node.method?(:define_method)
 
           method_name = node.send_node.first_argument
-          return if method_name.basic_literal? && allowed?(method_name.value)
+          return if method_name&.basic_literal? && allowed?(method_name.value)
 
           check_code_length(node)
         end

data/lib/rubocop/cop/metrics/perceived_complexity.rb

@@ -12,9 +12,15 @@ module RuboCop
       # nodes count. In contrast to the CyclomaticComplexity cop, this cop
       # considers `else` nodes as adding complexity.
       #
+      # A `case`/`in` branch whose pattern is a simple literal (e.g. `in 1`, `in "red"`, `in 1..10`)
+      # or a constant/type (e.g. `in Integer`) and has no guard is just as easy to read as a `when`
+      # branch, so it is discounted the same way. Branches with structural patterns (e.g. array,
+      # hash, or find patterns), bindings, alternatives, or a guard add the full complexity of
+      # a decision point.
+      #
       # @example
       #
-      #   def my_method                   # 1
+      #   def example_1                   # 1
       #     if cond                       # 1
       #       case var                    # 2 (0.8 + 4 * 0.2, rounded)
       #       when 1 then func_one
@@ -26,33 +32,58 @@ module RuboCop
       #       do_something until a && b   # 2
       #     end                           # ===
       #   end                             # 7 complexity points
+      #
+      #   def example_2                   # 1
+      #     case color                    # 1 (3 * 0.2, rounded)
+      #     in "red" then func_red
+      #     in "blue" then func_blue
+      #     in "green" then func_green
+      #     end                           # ===
+      #   end                             # 2 complexity points
       class PerceivedComplexity < CyclomaticComplexity
         MSG = 'Perceived complexity for `%<method>s` is too high. [%<complexity>d/%<max>d]'
 
-        COUNTED_NODES = (CyclomaticComplexity::COUNTED_NODES - [:when] + [:case]).freeze
+        COUNTED_NODES = (
+          CyclomaticComplexity::COUNTED_NODES - %i[when in_pattern] + %i[case case_match]
+        ).freeze
 
         private
 
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def complexity_score_for(node)
           case node.type
           when :case
-            # If cond is nil, that means each when has an expression that
-            # evaluates to true or false. It's just an alternative to
-            # if/elsif/elsif... so the when nodes count.
+            # If cond is nil, that means each when has an expression that evaluates to true or
+            # false. It's just an alternative to if/elsif/elsif... so the when nodes count.
             nb_branches = node.when_branches.length + (node.else_branch ? 1 : 0)
             if node.condition.nil?
               nb_branches
             else
-              # Otherwise, the case node gets 0.8 complexity points and each
-              # when gets 0.2.
+              # Otherwise, the case node gets 0.8 complexity points and each when gets 0.2.
               ((nb_branches * 0.2) + 0.8).round
             end
+          when :case_match
+            # Simple `in` branches are discounted like `when`, while structural patterns keep
+            # the full complexity of a decision point.
+            score = node.in_pattern_branches.sum { |branch| simple_in_pattern?(branch) ? 0.2 : 1 }
+            score += 0.2 if node.else_branch
+            score.round
           when :if
             node.else? && !node.elsif? ? 2 : 1
           else
             super
           end
         end
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+
+        def simple_in_pattern?(in_pattern_node)
+          # `in_pattern_node.children[1]` is the guard (`if`/`unless`), or `nil`.
+          return false unless in_pattern_node.children[1].nil?
+
+          # A scalar literal, a literal range, or a constant/type is as easy to read as a `when`.
+          pattern = in_pattern_node.pattern
+          pattern.literal? || pattern.const_type?
+        end
       end
     end
   end

data/lib/rubocop/cop/metrics/utils/code_length_calculator.rb

@@ -189,7 +189,7 @@ module RuboCop
           def source_from_node_with_heredoc(node)
             last_line = -1
             node.each_descendant do |descendant|
-              next unless descendant.source
+              next if descendant.loc.nil? || descendant.source_range.nil?
 
               descendant_last_line =
                 if heredoc_node?(descendant)

data/lib/rubocop/cop/metrics.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Cops for the `Metrics` department. The department's cops are registered for lazy loading
+    # and their files are loaded on demand.
+    module Metrics
+      extend LazyLoader
+
+      register_cop :CyclomaticComplexity, "#{__dir__}/metrics/cyclomatic_complexity"
+      register_cop :AbcSize, "#{__dir__}/metrics/abc_size"
+      register_cop :BlockLength, "#{__dir__}/metrics/block_length"
+      register_cop :BlockNesting, "#{__dir__}/metrics/block_nesting"
+      register_cop :ClassLength, "#{__dir__}/metrics/class_length"
+      register_cop :CollectionLiteralLength, "#{__dir__}/metrics/collection_literal_length"
+      register_cop :MethodLength, "#{__dir__}/metrics/method_length"
+      register_cop :ModuleLength, "#{__dir__}/metrics/module_length"
+      register_cop :ParameterLists, "#{__dir__}/metrics/parameter_lists"
+      register_cop :PerceivedComplexity, "#{__dir__}/metrics/perceived_complexity"
+
+      # Utility classes for `Metrics` department cops.
+      module Utils
+        autoload :AbcSizeCalculator, "#{__dir__}/metrics/utils/abc_size_calculator"
+        autoload :CodeLengthCalculator, "#{__dir__}/metrics/utils/code_length_calculator"
+        autoload :IteratingBlock, "#{__dir__}/metrics/utils/iterating_block"
+        autoload :RepeatedAttributeDiscount, "#{__dir__}/metrics/utils/repeated_attribute_discount"
+        autoload :RepeatedCsendDiscount, "#{__dir__}/metrics/utils/repeated_csend_discount"
+      end
+    end
+  end
+end

data/lib/rubocop/cop/migration/department_name.rb

@@ -50,10 +50,6 @@ module RuboCop
 
         private
 
-        def disable_comment_offset
-          Regexp.last_match(1).length
-        end
-
         def check_cop_name(name, comment, offset)
           start = comment.source_range.begin_pos + offset
           range = range_between(start, start + name.length)

data/lib/rubocop/cop/migration.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    # Cops for the `Migration` department. The department's cops are registered for lazy loading
+    # and their files are loaded on demand.
+    module Migration
+      extend LazyLoader
+
+      register_cop :DepartmentName, "#{__dir__}/migration/department_name"
+    end
+  end
+end

data/lib/rubocop/cop/mixin/allowed_methods.rb

@@ -25,11 +25,11 @@ module RuboCop
 
       # @api public
       def allowed_methods
-        if cop_config_deprecated_values.any?(Regexp)
-          cop_config_allowed_methods
-        else
-          cop_config_allowed_methods + cop_config_deprecated_values
-        end
+        @allowed_methods ||= if cop_config_deprecated_values.any?(Regexp)
+                               cop_config_allowed_methods
+                             else
+                               cop_config_allowed_methods + cop_config_deprecated_values
+                             end
       end
 
       def cop_config_allowed_methods

data/lib/rubocop/cop/mixin/allowed_pattern.rb

@@ -27,7 +27,7 @@ module RuboCop
       end
 
       def matches_allowed_pattern?(line)
-        allowed_patterns.any? { |pattern| Regexp.new(pattern).match?(line) }
+        allowed_pattern_regexps.any? { |pattern| pattern.match?(line) }
       end
 
       # @deprecated Use matches_allowed_pattern? instead
@@ -49,6 +49,10 @@ module RuboCop
         end
       end
 
+      def allowed_pattern_regexps
+        @allowed_pattern_regexps ||= allowed_patterns.map { |pattern| Regexp.new(pattern) }
+      end
+
       def cop_config_patterns_values
         @cop_config_patterns_values ||=
           Array(cop_config.fetch('AllowedPatterns', [])) +

data/lib/rubocop/cop/mixin/check_line_breakable.rb

@@ -61,11 +61,13 @@ module RuboCop
       # @api private
       def extract_breakable_node_from_elements(node, elements, max)
         return unless breakable_collection?(node, elements)
-        return if safe_to_ignore?(node)
 
+        # Check the cheap conditions first, `safe_to_ignore?` may traverse all elements of
+        # a containing collection.
         line = processed_source.lines[node.first_line - 1]
+        return if max && line.length <= max
         return if processed_source.line_with_comment?(node.loc.line)
-        return if line.length <= max
+        return if safe_to_ignore?(node)
 
         extract_first_element_over_column_limit(node, elements, max)
       end
@@ -173,20 +175,36 @@ module RuboCop
         node.each_ancestor.find do |ancestor|
           if ancestor.type?(:hash, :array) &&
              breakable_collection?(ancestor, ancestor.children)
-            return children_could_be_broken_up?(ancestor.children)
+            return children_could_be_broken_up?(ancestor, ancestor.children)
           end
 
           next unless ancestor.call_type?
 
           args = process_args(ancestor.arguments)
-          return children_could_be_broken_up?(args) if breakable_collection?(ancestor, args)
+          if breakable_collection?(ancestor, args)
+            return children_could_be_broken_up?(ancestor, args)
+          end
         end
 
         false
       end
 
       # @api private
-      def children_could_be_broken_up?(children)
+      # The result depends only on the given node, but the check may traverse all children of
+      # a large collection and is repeated for each contained element, so memoize it per node.
+      def children_could_be_broken_up?(node, children)
+        if @check_line_breakable_processed_source != processed_source
+          @check_line_breakable_processed_source = processed_source
+          @children_could_be_broken_up_cache = {}.compare_by_identity
+        end
+
+        @children_could_be_broken_up_cache.fetch(node) do
+          @children_could_be_broken_up_cache[node] = compute_children_could_be_broken_up?(children)
+        end
+      end
+
+      # @api private
+      def compute_children_could_be_broken_up?(children)
         return false if all_on_same_line?(children)
 
         last_seen_line = -1

data/lib/rubocop/cop/mixin/endless_method_rewriter.rb

@@ -5,20 +5,28 @@ module RuboCop
     # Common functionality for rewriting endless methods to normal method definitions
     module EndlessMethodRewriter
       def correct_to_multiline(corrector, node)
-        replacement = <<~RUBY.strip
-          def #{node.method_name}#{arguments(node)}
-            #{node.body.source}
-          end
-        RUBY
+        replacement = [
+          "def #{receiver(node)}#{node.method_name}#{arguments(node)}",
+          "#{indent(node, offset: configured_indentation_width)}#{node.body.source}",
+          "#{indent(node)}end"
+        ].join("\n")
 
         corrector.replace(node, replacement)
       end
 
       private
 
+      def receiver(node)
+        node.receiver ? "#{node.receiver.source}#{node.loc.operator.source}" : ''
+      end
+
       def arguments(node, missing = '')
         node.arguments.any? ? node.arguments.source : missing
       end
+
+      def configured_indentation_width
+        cop_config['IndentationWidth'] || config.for_cop('Layout/IndentationWidth')['Width'] || 2
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/forbidden_pattern.rb

@@ -5,12 +5,16 @@ module RuboCop
     # This module encapsulates the ability to forbid certain patterns in a cop.
     module ForbiddenPattern
       def forbidden_pattern?(name)
-        forbidden_patterns.any? { |pattern| Regexp.new(pattern).match?(name) }
+        forbidden_pattern_regexps.any? { |pattern| pattern.match?(name) }
       end
 
       def forbidden_patterns
         cop_config.fetch('ForbiddenPatterns', [])
       end
+
+      def forbidden_pattern_regexps
+        @forbidden_pattern_regexps ||= forbidden_patterns.map { |pattern| Regexp.new(pattern) }
+      end
     end
   end
 end

data/lib/rubocop/cop/mixin/hash_alignment_styles.rb

@@ -96,20 +96,37 @@ module RuboCop
         end
 
         def hash_rocket_delta(first_pair, current_pair)
-          first_pair.loc.column + max_key_width(first_pair.parent) + 1 -
-            current_pair.loc.operator.column
+          target_operator_column(first_pair) - current_pair.loc.operator.column
         end
 
         def value_delta(first_pair, current_pair)
-          correct_value_column = first_pair.key.loc.column +
-                                 max_key_width(first_pair.parent) +
-                                 max_delimiter_width(first_pair.parent)
+          correct_value_column = target_operator_column(first_pair) +
+                                 max_delimiter_width(first_pair.parent) - 1
 
           current_pair.value_omission? ? 0 : correct_value_column - current_pair.value.loc.column
         end
 
+        # The column the separator should land on: the shared key margin
+        # plus the widest single-line key, or, if larger, a multiline key's
+        # own last-line end column. The latter can't be measured from a
+        # multiline key's (newline-including) source length, so it's a
+        # separate candidate rather than folded into `max_key_width`.
+        def target_operator_column(first_pair)
+          hash_node = first_pair.parent
+          candidates = multiline_key_end_columns(hash_node)
+
+          key_width = max_key_width(hash_node)
+          candidates << (first_pair.loc.column + key_width + 1) if key_width.positive?
+
+          candidates.max
+        end
+
+        def multiline_key_end_columns(hash_node)
+          hash_node.keys.reject(&:single_line?).map { |key| key.source_range.end.column + 1 }
+        end
+
         def max_key_width(hash_node)
-          hash_node.keys.map { |key| key.source.length }.max
+          hash_node.keys.select(&:single_line?).map { |key| key.source.length }.max || 0
         end
 
         def max_delimiter_width(hash_node)

data/lib/rubocop/cop/mixin/hash_subset.rb

@@ -182,10 +182,18 @@ module RuboCop
         return ":\"#{value.source}\"" if value.dsym_type?
         return "\"#{value.source}\"" if value.dstr_type?
         return ":#{value.source}" if value.sym_type?
+        # The element of a `%w` array can contain characters that are special
+        # inside a single-quoted string (e.g. a `'`), so escape them rather than
+        # wrapping the raw source.
+        return to_single_quoted(value.value) if value.str_type?
 
         "'#{value.source}'"
       end
 
+      def to_single_quoted(string)
+        "'#{string.gsub(/['\\]/) { |character| "\\#{character}" }}'"
+      end
+
       def except_key(node)
         key_arg = node.argument_list.first.source
         body, = extract_body_if_negated(node.body)

data/lib/rubocop/cop/mixin/hash_transform_method.rb

@@ -94,6 +94,10 @@ module RuboCop
 
         return unless captures.use_transformed_argname?
 
+        # A splat transforming expression (e.g. `[k, *v]`) can't be used as a
+        # standalone block return value, so the rewrite would produce invalid Ruby.
+        return if captures.transforming_body_expr.splat_type?
+
         message = "Prefer `#{new_method_name}` over `#{match_desc}`."
         add_offense(node, message: message) do |corrector|
           correction = prepare_correction(node)