rubocop 1.75.1 → 1.75.6

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

@@ -4,6 +4,7 @@ module RuboCop
   module Cop
     module Style
       # Checks for inheritance from `Data.define` to avoid creating the anonymous parent class.
+      # Inheriting from `Data.define` adds a superfluous level in inheritance tree.
       #
       # @safety
       #   Autocorrection is unsafe because it will change the inheritance
@@ -17,12 +18,18 @@ module RuboCop
       #     end
       #   end
       #
+      #   Person.ancestors
+      #   # => [Person, #<Class:0x000000010b4e14a0>, Data, (...)]
+      #
       #   # good
       #   Person = Data.define(:first_name, :last_name) do
       #     def age
       #       42
       #     end
       #   end
+      #
+      #   Person.ancestors
+      #   # => [Person, Data, (...)]
       class DataInheritance < Base
         include RangeHelp
         extend AutoCorrector

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

@@ -102,7 +102,7 @@ module RuboCop
 
         def find_def_node_from_ascendant(node)
           return unless (parent = node.parent)
-          return parent if parent.type?(:def, :defs)
+          return parent if parent.any_def_type?
           return node.parent.child_nodes.first if define_method?(parent)
 
           find_def_node_from_ascendant(node.parent)

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

@@ -6,6 +6,10 @@ module RuboCop
       # Checks for the use of a method, the result of which
       # would be a literal, like an empty array, hash, or string.
       #
+      # NOTE: When frozen string literals are enabled, `String.new`
+      # isn't corrected to an empty string since the former is
+      # mutable and the latter would be frozen.
+      #
       # @example
       #   # bad
       #   a = Array.new

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

@@ -4,12 +4,12 @@ module RuboCop
   module Cop
     module Style
       # Ensures that eval methods (`eval`, `instance_eval`, `class_eval`
-      # and `module_eval`) are given filename and line number values (`\_\_FILE\_\_`
-      # and `\_\_LINE\_\_`). This data is used to ensure that any errors raised
+      # and `module_eval`) are given filename and line number values (`+__FILE__+`
+      # and `+__LINE__+`). This data is used to ensure that any errors raised
       # within the evaluated code will be given the correct identification
       # in a backtrace.
       #
-      # The cop also checks that the line number given relative to `\_\_LINE\_\_` is
+      # The cop also checks that the line number given relative to `+__LINE__+` is
       # correct.
       #
       # This cop will autocorrect incorrect or missing filename and line number

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

@@ -65,7 +65,7 @@ module RuboCop
           yielding_block?(block_node) do |send_node, block_args, yield_args|
             return unless yielding_arguments?(block_args, yield_args)
 
-            def_node = block_node.each_ancestor(:def, :defs).first
+            def_node = block_node.each_ancestor(:any_def).first
             # if `yield` is being called outside of a method context, ignore
             # this is not a valid ruby pattern, but can happen in haml or erb,
             # so this can cause crashes in haml_lint
@@ -151,7 +151,7 @@ module RuboCop
         end
 
         def build_new_arguments_for_zsuper(node)
-          def_node = node.each_ancestor(:def, :defs).first
+          def_node = node.each_ancestor(:any_def).first
           def_node.arguments.map do |arg|
             arg.optarg_type? ? arg.node_parts[0] : arg.source
           end

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

@@ -151,7 +151,7 @@ module RuboCop
 
         def frozen_string_literal_comment(processed_source)
           processed_source.tokens.find do |token|
-            token.text.start_with?(FROZEN_STRING_LITERAL_REGEXP)
+            MagicComment.parse(token.text).frozen_string_literal_specified?
           end
         end
 
@@ -189,8 +189,9 @@ module RuboCop
 
         def enable_comment(corrector)
           comment = frozen_string_literal_comment(processed_source)
+          replacement = MagicComment.parse(comment.text).new_frozen_string_literal(true)
 
-          corrector.replace(line_range(comment.line), FROZEN_STRING_LITERAL_ENABLED)
+          corrector.replace(line_range(comment.line), replacement)
         end
 
         def insert_comment(corrector)

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

@@ -8,6 +8,9 @@ module RuboCop
       # reassign (possibly to redirect some stream) constants in Ruby, you'll get
       # an interpreter warning if you do so.
       #
+      # Additionally, `$stdout/$stderr/$stdin` can safely be accessed in a Ractor because they
+      # are ractor-local, while `STDOUT/STDERR/STDIN` will raise `Ractor::IsolationError`.
+      #
       # @safety
       #   Autocorrection is unsafe because `STDOUT` and `$stdout` may point to different
       #   objects, for example.

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

@@ -40,7 +40,6 @@ module RuboCop
       class HashFetchChain < Base
         extend AutoCorrector
         extend TargetRubyVersion
-        include IgnoredNode
 
         MSG = 'Use `%<replacement>s` instead.'
         RESTRICT_ON_SEND = %i[fetch].freeze

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

@@ -76,6 +76,9 @@ module RuboCop
       #   # good
       #   {foo:, bar:}
       #
+      #   # good - allowed to mix syntaxes
+      #   {foo:, bar: baz}
+      #
       # @example EnforcedShorthandSyntax: never
       #
       #   # bad

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Looks for uses of `\_.each_with_object({}) {...}`,
-      # `\_.map {...}.to_h`, and `Hash[\_.map {...}]` that are actually just
+      # Looks for uses of `+_.each_with_object({}) {...}+`,
+      # `+_.map {...}.to_h+`, and `+Hash[_.map {...}]+` that are actually just
       # transforming the keys of a hash, and tries to use a simpler & faster
       # call to `transform_keys` instead.
       # It should only be enabled on Ruby version 2.5 or newer.

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

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Looks for uses of `\_.each_with_object({}) {...}`,
-      # `\_.map {...}.to_h`, and `Hash[\_.map {...}]` that are actually just
+      # Looks for uses of `+_.each_with_object({}) {...}+`,
+      # `+_.map {...}.to_h+`, and `+Hash[_.map {...}]+` that are actually just
       # transforming the values of a hash, and tries to use a simpler & faster
       # call to `transform_values` instead.
       #

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

@@ -189,7 +189,7 @@ module RuboCop
           end
         end
 
-        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
         def check_expressions(node, expressions, insert_position)
           return if expressions.any?(&:nil?)
 
@@ -197,7 +197,7 @@ module RuboCop
 
           expressions.each do |expression|
             add_offense(expression) do |corrector|
-              next if node.if_type? && node.ternary?
+              next if node.if_type? && (node.ternary? || node.then?)
 
               range = range_by_whole_lines(expression.source_range, include_final_newline: true)
               corrector.remove(range)
@@ -213,7 +213,7 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
+        # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
 
         def correct_assignment(corrector, node, expression, insert_position)
           if insert_position == :after_condition

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

@@ -23,6 +23,17 @@ module RuboCop
       # end
       # ----
       #
+      # The code `def method_name = body if condition` is considered a bad case by
+      # `Style/AmbiguousEndlessMethodDefinition` cop. So, to respect the user's intention to use
+      # an endless method definition in the `if` body, the following code is allowed:
+      #
+      # [source,ruby]
+      # ----
+      # if condition
+      #   def method_name = body
+      # end
+      # ----
+      #
       # NOTE: It is allowed when `defined?` argument has an undefined value,
       # because using the modifier form causes the following incompatibility:
       #
@@ -77,10 +88,14 @@ module RuboCop
           [Style::SoleNestedConditional]
         end
 
+        # rubocop:disable Metrics/AbcSize
         def on_if(node)
+          return if endless_method?(node.body)
+
           condition = node.condition
           return if defined_nodes(condition).any? { |n| defined_argument_is_undefined?(node, n) } ||
                     pattern_matching_nodes(condition).any?
+
           return unless (msg = message(node))
 
           add_offense(node.loc.keyword, message: format(msg, keyword: node.keyword)) do |corrector|
@@ -90,9 +105,14 @@ module RuboCop
             ignore_node(node)
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         private
 
+        def endless_method?(body)
+          body&.any_def_type? && body.endless?
+        end
+
         def defined_nodes(condition)
           if condition.defined_type?
             [condition]

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

@@ -10,7 +10,7 @@ module RuboCop
       # `nonzero?` method is allowed by default.
       # These are customizable with `AllowedMethods` option.
       #
-      # This cop targets only `if`s with a single `elsif` or `else` branch. The following
+      # This cop targets only ``if``s with a single `elsif` or `else` branch. The following
       # code will be allowed, because it has two `elsif` branches:
       #
       # [source,ruby]

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

@@ -42,7 +42,7 @@ module RuboCop
           return if kwarg_nodes.empty?
 
           add_offense(node) do |corrector|
-            defining_node = node.each_ancestor(:def, :defs, :block).first
+            defining_node = node.each_ancestor(:any_def, :block).first
             next if processed_source.contains_comment?(arguments_range(defining_node))
             next unless node.parent.find(&:kwoptarg_type?) == node
 

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

@@ -54,9 +54,14 @@ module RuboCop
 
         def prefer(node)
           receiver = node.receiver.source
-          arguments = node.arguments.map(&:source).join(', ')
           dot = node.loc.dot.source
-          method = explicit_style? ? "call(#{arguments})" : "(#{arguments})"
+          call_arguments = if node.arguments.empty?
+                             ''
+                           else
+                             arguments = node.arguments.map(&:source).join(', ')
+                             "(#{arguments})"
+                           end
+          method = explicit_style? ? "call#{call_arguments}" : "(#{arguments})"
 
           "#{receiver}#{dot}#{method}"
         end

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

@@ -212,9 +212,11 @@ module RuboCop
         end
 
         def correct_push_node(corrector, push_node)
+          arg_node = push_node.first_argument
           range = push_node.source_range
-          arg_range = push_node.first_argument.source_range
+          arg_range = arg_node.source_range
 
+          corrector.wrap(arg_node, '{ ', ' }') if arg_node.hash_type? && !arg_node.braces?
           corrector.remove(range_between(range.begin_pos, arg_range.begin_pos))
           corrector.remove(range_between(arg_range.end_pos, range.end_pos))
         end

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

@@ -49,7 +49,7 @@ module RuboCop
 
           def inside_endless_method_def?(node)
             # parens are required around arguments inside an endless method
-            node.each_ancestor(:def, :defs).any?(&:endless?) && node.arguments.any?
+            node.each_ancestor(:any_def).any?(&:endless?) && node.arguments.any?
           end
 
           def require_parentheses_for_hash_value_omission?(node) # rubocop:disable Metrics/PerceivedComplexity
@@ -222,6 +222,9 @@ module RuboCop
           end
 
           def unary_literal?(node)
+            # NOTE: should be removed after releasing https://github.com/rubocop/rubocop-ast/pull/379
+            return node.source.match?(/\A[+-]/) if node.complex_type?
+
             (node.numeric_type? && node.sign?) ||
               (node.parent&.send_type? && node.parent.unary_operation?)
           end

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

@@ -23,11 +23,13 @@ module RuboCop
               'clause in a multiline statement.'
 
         def on_if(node)
+          return if part_of_ignored_node?(node)
           return unless node.modifier_form? && node.body.multiline?
 
           add_offense(node, message: format(MSG, keyword: node.keyword)) do |corrector|
             corrector.replace(node, to_normal_if(node))
           end
+          ignore_node(node)
         end
 
         private

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

@@ -45,7 +45,7 @@ module RuboCop
           # Report offense only if changing case doesn't change semantics,
           # i.e., if the string would become dynamic or has special characters.
           ast = parse(corrected(node.source)).ast
-          return if node.children != ast.children
+          return if node.children != ast&.children
 
           add_offense(node.loc.begin) do |corrector|
             corrector.replace(node, corrected(node.source))

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

@@ -230,6 +230,14 @@ module RuboCop
           node.type?(:kwsplat, :forwarded_kwrestarg)
         end
 
+        def wrap_arguments_with_parens(condition)
+          method = condition.source_range.begin.join(condition.loc.selector.end)
+          arguments = condition.first_argument.source_range.begin.join(condition.source_range.end)
+
+          "#{method.source}(#{arguments.source})"
+        end
+
+        # rubocop:disable Metrics/AbcSize
         def if_source(if_branch, arithmetic_operation)
           if branches_have_method?(if_branch.parent) && if_branch.parenthesized?
             if_branch.source.delete_suffix(')')
@@ -238,11 +246,15 @@ module RuboCop
 
             "#{if_branch.receiver.source} #{if_branch.method_name} (#{argument_source}"
           elsif if_branch.true_type?
-            if_branch.parent.condition.source
+            condition = if_branch.parent.condition
+            return condition.source if condition.arguments.empty?
+
+            wrap_arguments_with_parens(condition)
           else
             if_branch.source
           end
         end
+        # rubocop:enable Metrics/AbcSize
 
         def else_source(else_branch, arithmetic_operation) # rubocop:disable Metrics/AbcSize
           if arithmetic_operation

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

@@ -20,7 +20,7 @@ module RuboCop
 
         MSG = 'Remove the redundant current directory path.'
         RESTRICT_ON_SEND = %i[require_relative].freeze
-        CURRENT_DIRECTORY_PREFIX = %r{./+}.freeze
+        CURRENT_DIRECTORY_PREFIX = %r{\./+}.freeze
         REDUNDANT_CURRENT_DIRECTORY_PREFIX = /\A#{CURRENT_DIRECTORY_PREFIX}/.freeze
 
         def on_send(node)

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

@@ -181,9 +181,7 @@ module RuboCop
           ARGUMENT_TYPES.include?(next_token.type)
         end
 
-        # rubocop:disable Metrics/AbcSize
         def argument_newline?(node)
-          node = node.to_a.last if node.assignment?
           return false if node.parenthesized_call?
 
           node = node.children.first if node.root? && node.begin_type?
@@ -196,7 +194,6 @@ module RuboCop
             node.loc.selector.line != node.first_argument.loc.line
           end
         end
-        # rubocop:enable Metrics/AbcSize
 
         def find_node_for_line(last_line)
           processed_source.ast.each_node do |node|

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

@@ -78,7 +78,7 @@ module RuboCop
           ancestor = node.ancestors.first
           return false unless ancestor
 
-          !ancestor.type?(:begin, :def, :any_block)
+          !ancestor.type?(:begin, :any_def, :any_block)
         end
 
         def allowed_ternary?(node)
@@ -98,7 +98,7 @@ module RuboCop
           return false unless node.type?(:send, :super, :yield)
 
           node.arguments.one? && !node.parenthesized? &&
-            !node.arithmetic_operation? && node.first_argument.begin_type?
+            !node.operator_method? && node.first_argument.begin_type?
         end
 
         def multiline_control_flow_statements?(node)
@@ -134,7 +134,9 @@ module RuboCop
           node = begin_node.children.first
 
           if (message = find_offense_message(begin_node, node))
-            begin_node = begin_node.parent if node.range_type?
+            if node.range_type? && !argument_of_parenthesized_method_call?(begin_node)
+              begin_node = begin_node.parent
+            end
 
             return offense(begin_node, message)
           end
@@ -155,6 +157,7 @@ module RuboCop
             return 'an expression'
           end
           return 'an interpolated expression' if interpolation?(begin_node)
+          return 'a method argument' if argument_of_parenthesized_method_call?(begin_node)
 
           return if begin_node.chained?
 
@@ -177,6 +180,20 @@ module RuboCop
         # @!method interpolation?(node)
         def_node_matcher :interpolation?, '[^begin ^^dstr]'
 
+        def argument_of_parenthesized_method_call?(begin_node)
+          node = begin_node.children.first
+          return false if node.basic_conditional? || method_call_parentheses_required?(node)
+          return false unless (parent = begin_node.parent)
+
+          parent.call_type? && parent.parenthesized? && parent.receiver != begin_node
+        end
+
+        def method_call_parentheses_required?(node)
+          return false unless node.call_type?
+
+          (node.receiver.nil? || node.loc.dot) && node.arguments.any?
+        end
+
         def allow_in_multiline_conditions?
           !!config.for_enabled_cop('Style/ParenthesesAroundCondition')['AllowInMultilineConditions']
         end

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

@@ -47,7 +47,7 @@ module RuboCop
 
         def on_return(node)
           # Check Lint/NonLocalExitFromIterator first before this cop
-          node.each_ancestor(:block, :def, :defs) do |n|
+          node.each_ancestor(:block, :any_def) do |n|
             break if scoped_node?(n)
 
             send_node, args_node, _body_node = *n
@@ -83,7 +83,7 @@ module RuboCop
         end
 
         def scoped_node?(node)
-          node.type?(:def, :defs) || node.lambda?
+          node.any_def_type? || node.lambda?
         end
 
         # @!method chained_send?(node)

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

@@ -174,12 +174,17 @@ module RuboCop
               range_with_surrounding_space(range: lhs.source_range, side: :right),
               range_with_surrounding_space(range: lhs_operator_range, side: :right),
               offense_range: range_between(lhs.source_range.begin_pos, rhs.source_range.end_pos)
-            )
+            ) do |corrector|
+              corrector.replace(rhs_receiver, lhs_receiver.source)
+            end
+            ignore_node(node)
           end
         end
 
         def report_offense(node, rhs, rhs_receiver, *removal_ranges, offense_range: node)
           add_offense(offense_range) do |corrector|
+            next if ignored_node?(node)
+
             # If the RHS is an `or` we cannot safely autocorrect because in order to remove
             # the non-nil check we need to add safe-navs to all clauses where the receiver is used
             next if and_with_rhs_or?(node)
@@ -227,7 +232,7 @@ module RuboCop
         end
 
         def offending_node?(node, lhs_receiver, rhs, rhs_receiver) # rubocop:disable Metrics/CyclomaticComplexity
-          return false if lhs_receiver != rhs_receiver || rhs_receiver.nil?
+          return false if !matching_nodes?(lhs_receiver, rhs_receiver) || rhs_receiver.nil?
           return false if use_var_only_in_unless_modifier?(node, lhs_receiver)
           return false if chain_length(rhs, rhs_receiver) > max_chain_length
           return false if unsafe_method_used?(rhs, rhs_receiver.parent)
@@ -306,11 +311,21 @@ module RuboCop
 
           receiver = method_chain.receiver
 
-          return receiver if receiver == checked_variable
+          return receiver if matching_nodes?(receiver, checked_variable)
 
           find_matching_receiver_invocation(receiver, checked_variable)
         end
 
+        def matching_nodes?(left, right)
+          left == right || matching_call_nodes?(left, right)
+        end
+
+        def matching_call_nodes?(left, right)
+          return false unless left && right.respond_to?(:call_type?)
+
+          left.call_type? && right.call_type? && left.children == right.children
+        end
+
         def chain_length(method_chain, method)
           method.each_ancestor(:call).inject(0) do |total, ancestor|
             break total + 1 if ancestor == method_chain

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

@@ -185,8 +185,10 @@ module RuboCop
         end
 
         def add_parentheses?(node)
-          node.assignment? || (node.operator_keyword? && !node.and_type?) ||
-            (node.call_type? && node.arguments.any? && !node.parenthesized?)
+          return true if node.assignment? || (node.operator_keyword? && !node.and_type?)
+          return false unless node.call_type?
+
+          (node.arguments.any? && !node.parenthesized?) || node.prefix_not?
         end
 
         def parenthesized_method_arguments(node)

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

@@ -51,7 +51,6 @@ module RuboCop
       #   Pathname.new('/') + 'test'
       #
       class StringConcatenation < Base
-        include RangeHelp
         extend AutoCorrector
 
         MSG = 'Prefer string interpolation to string concatenation.'
@@ -147,7 +146,7 @@ module RuboCop
             when :str
               adjust_str(part)
             when :dstr
-              part.children.all?(&:str_type?) ? adjust_str(part) : contents_range(part).source
+              part.children.all?(&:str_type?) ? adjust_str(part) : part.value
             else
               "\#{#{part.source}}"
             end

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

@@ -3,7 +3,8 @@
 module RuboCop
   module Cop
     module Style
-      # Checks for inheritance from Struct.new.
+      # Checks for inheritance from `Struct.new`. Inheriting from `Struct.new`
+      # adds a superfluous level in inheritance tree.
       #
       # @safety
       #   Autocorrection is unsafe because it will change the inheritance
@@ -17,12 +18,18 @@ module RuboCop
       #     end
       #   end
       #
+      #   Person.ancestors
+      #   # => [Person, #<Class:0x000000010b4e14a0>, Struct, (...)]
+      #
       #   # good
       #   Person = Struct.new(:first_name, :last_name) do
       #     def age
       #       42
       #     end
       #   end
+      #
+      #   Person.ancestors
+      #   # => [Person, Struct, (...)]
       class StructInheritance < Base
         include RangeHelp
         extend AutoCorrector

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

@@ -68,7 +68,6 @@ module RuboCop
       class SuperArguments < Base
         extend AutoCorrector
 
-        DEF_TYPES = %i[def defs].freeze
         ASSIGN_TYPES = %i[or_asgn lvasgn].freeze
 
         MSG = 'Call `super` without arguments and parentheses when the signature is identical.'
@@ -100,7 +99,7 @@ module RuboCop
             # `super` used within the block is always allowed.
             break if node.any_block_type? && !block_sends_to_super?(super_node, node)
 
-            break node if DEF_TYPES.include?(node.type)
+            break node if node.any_def_type?
           end
         end
 

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

@@ -79,10 +79,16 @@ module RuboCop
       #   # bad
       #   method(1, 2,)
       #
+      #   # bad
+      #   object[1, 2,]
+      #
       #   # good
       #   method(1, 2)
       #
       #   # good
+      #   object[1, 2]
+      #
+      #   # good
       #   method(
       #     1,
       #     2
@@ -96,7 +102,7 @@ module RuboCop
         end
 
         def on_send(node)
-          return unless node.arguments? && node.parenthesized?
+          return unless node.arguments? && (node.parenthesized? || node.method?(:[]))
 
           check(node, node.arguments, 'parameter of %<article>s method call',
                 node.last_argument.source_range.end_pos,

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

@@ -11,7 +11,7 @@ module RuboCop
       # * `comma`: Requires a comma after the last item in an array, but only when each item is on
       # its own line.
       # * `diff_comma`: Requires a comma after the last item in an array, but only when that item is
-      # followed by an immediate newline.
+      # followed by an immediate newline, even if there is an inline comment on the same line.
       # * `no_comma`: Does not require a comma after the last item in an array
       #
       # @example EnforcedStyleForMultiline: consistent_comma

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

@@ -11,7 +11,7 @@ module RuboCop
       # * `comma`: Requires a comma after the last item in a hash, but only when each item is on its
       # own line.
       # * `diff_comma`: Requires a comma after the last item in a hash, but only when that item is
-      # followed by an immediate newline.
+      # followed by an immediate newline, even if there is an inline comment on the same line.
       # * `no_comma`: Does not require a comma after the last item in a hash
       #
       # @example EnforcedStyleForMultiline: consistent_comma