rubocop 1.56.0 → 1.57.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 76532b5c0c7ccf0baff454ad37e17c405e4f827a0c8323ce1a5aab0ee9e78c19
-  data.tar.gz: fe2f7d727d5addd930a762ebe7fb34a38845164fed801744a6802ab91e6ba779
+  metadata.gz: 28726dbde536af4bb4a8f7cc92d9c6ef3ddfa6c63b01a76317c2a9121a3318fa
+  data.tar.gz: 977ac77a446b41c15b0ce61795d1911d8620c47f439ab25274a5fd00586e79d2
 SHA512:
-  metadata.gz: ff206ac0d02084dd7014818da655f5f8d718ac1bb4bfc2f781d3c007839096a142236ded54d30084fa7b3e1689205ff7a8bc7ad7eee3ffea2d809e4610d6a1ae
-  data.tar.gz: aaa03f29b7669ffcf6fdcb16b7da4c38a6bc62187eb91d6347e3ada22f396370b6564177eb3a040fd5ddd3eeea9cf8b3ff51943e79c3d0ad410508a75bb3177b
+  metadata.gz: 5d87aae9334ac67e671b3b584ae853aa06e14893302a297315a1e746535863b0751b620d6dd35c96a7d3721b2be53cd01dde42b47f722af68365056f155a083e
+  data.tar.gz: 6ae78b00947a397723220aa271f260bdda5f44c4f45b7b4dabda984b9b176d344dc386391e79b2d40beb6a347fbde99f3aa970d4f6f23b91d441cced03f345a1

data/README.md

@@ -53,7 +53,7 @@ To prevent an unwanted RuboCop update you might want to use a conservative versi
 in your `Gemfile`:
 
 ```rb
-gem 'rubocop', '~> 1.56', require: false
+gem 'rubocop', '~> 1.57', require: false
 ```
 
 See [our versioning policy](https://docs.rubocop.org/rubocop/versioning.html) for further details.

data/config/default.yml

@@ -2170,7 +2170,9 @@ Lint/RedundantRegexpQuantifiers:
 Lint/RedundantRequireStatement:
   Description: 'Checks for unnecessary `require` statement.'
   Enabled: true
+  SafeAutoCorrect: false
   VersionAdded: '0.76'
+  VersionChanged: '1.57'
 
 Lint/RedundantSafeNavigation:
   Description: 'Checks for redundant safe navigation calls.'
@@ -3354,7 +3356,9 @@ Style/ClassEqualityComparison:
   Description: 'Enforces the use of `Object#instance_of?` instead of class comparison for equality.'
   StyleGuide: '#instance-of-vs-class-comparison'
   Enabled: true
+  SafeAutoCorrect: false
   VersionAdded: '0.93'
+  VersionChanged: '1.57'
   AllowedMethods:
     - ==
     - equal?
@@ -3409,6 +3413,7 @@ Style/CollectionMethods:
   PreferredMethods:
     collect: 'map'
     collect!: 'map!'
+    collect_concat: 'flat_map'
     inject: 'reduce'
     detect: 'find'
     find_all: 'select'
@@ -4130,12 +4135,6 @@ Style/InvertibleUnlessCondition:
     :none?: :any?
     :even?: :odd?
     :odd?: :even?
-    # `ActiveSupport` defines some common inverse methods. They are listed below,
-    # and not enabled by default.
-    # :present?: :blank?
-    # :blank?: :present?
-    # :include?: :exclude?
-    # :exclude?: :include?
 
 Style/IpAddresses:
   Description: "Don't include literal IP addresses in code."
@@ -4925,7 +4924,9 @@ Style/RedundantFilterChain:
                   Identifies usages of `any?`, `empty?`, `none?` or `one?` predicate methods chained to
                   `select`/`filter`/`find_all` and change them to use predicate method instead.
   Enabled: pending
+  SafeAutoCorrect: false
   VersionAdded: '1.52'
+  VersionChanged: '1.57'
 
 Style/RedundantFreeze:
   Description: "Checks usages of Object#freeze on immutable objects."
@@ -5187,6 +5188,11 @@ Style/SingleLineBlockParams:
         - acc
         - elem
 
+Style/SingleLineDoEndBlock:
+  Description: 'Checks for single-line `do`...`end` blocks.'
+  Enabled: pending
+  VersionAdded: '1.57'
+
 Style/SingleLineMethods:
   Description: 'Avoid single-line methods.'
   StyleGuide: '#no-single-line-methods'

data/lib/rubocop/cli.rb

@@ -11,7 +11,7 @@ module RuboCop
     STATUS_ERROR       = 2
     STATUS_INTERRUPTED = Signal.list['INT'] + 128
     DEFAULT_PARALLEL_OPTIONS = %i[
-      color debug display_style_guide display_time display_only_fail_level_offenses
+      color config debug display_style_guide display_time display_only_fail_level_offenses
       display_only_failed except extra_details fail_level fix_layout format
       ignore_disable_comments lint only only_guide_cops require safe
       autocorrect safe_autocorrect autocorrect_all

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -82,7 +82,9 @@ module RuboCop
           node.array_type? && node.percent_literal?
         end
 
-        percent_array.map(&:source_range).find { |range| range.overlaps?(offense_range) }
+        percent_array.map(&:source_range).find do |range|
+          offense_range.begin_pos > range.begin_pos && range.overlaps?(offense_range)
+        end
       end
 
       def range_of_first_line(range)

data/lib/rubocop/cop/bundler/duplicated_group.rb

@@ -5,6 +5,24 @@ module RuboCop
     module Bundler
       # A Gem group, or a set of groups, should be listed only once in a Gemfile.
       #
+      # For example, if the values of `source`, `git`, `platforms`, or `path`
+      # surrounding `group` are different, no offense will be registered:
+      #
+      # [source,ruby]
+      # -----
+      # platforms :ruby do
+      #   group :default do
+      #     gem 'openssl'
+      #   end
+      # end
+      #
+      # platforms :jruby do
+      #   group :default do
+      #     gem 'jruby-openssl'
+      #   end
+      # end
+      # -----
+      #
       # @example
       #   # bad
       #   group :development do
@@ -42,27 +60,35 @@ module RuboCop
 
         MSG = 'Gem group `%<group_name>s` already defined on line ' \
               '%<line_of_first_occurrence>d of the Gemfile.'
+        SOURCE_BLOCK_NAMES = %i[source git platforms path].freeze
+
+        # @!method group_declarations(node)
+        def_node_search :group_declarations, '(send nil? :group ...)'
 
         def on_new_investigation
           return if processed_source.blank?
 
           duplicated_group_nodes.each do |nodes|
             nodes[1..].each do |node|
-              register_offense(node, node.arguments.map(&:value).join(', '), nodes.first.first_line)
+              group_name = node.arguments.map(&:source).join(', ')
+
+              register_offense(node, group_name, nodes.first.first_line)
             end
           end
         end
 
         private
 
-        # @!method group_declarations(node)
-        def_node_search :group_declarations, '(send nil? :group ...)'
-
         def duplicated_group_nodes
-          group_declarations(processed_source.ast)
-            .group_by { |node| node.arguments.map(&:value).map(&:to_s).sort }
-            .values
-            .select { |nodes| nodes.size > 1 }
+          group_declarations = group_declarations(processed_source.ast)
+          group_keys = group_declarations.group_by do |node|
+            source_key = find_source_key(node)
+            group_attributes = group_attributes(node).sort.join
+
+            "#{source_key}#{group_attributes}"
+          end
+
+          group_keys.values.select { |nodes| nodes.size > 1 }
         end
 
         def register_offense(node, group_name, line_of_first_occurrence)
@@ -75,6 +101,26 @@ module RuboCop
           )
           add_offense(offense_location, message: message)
         end
+
+        def find_source_key(node)
+          source_block = node.each_ancestor(:block).find do |block_node|
+            SOURCE_BLOCK_NAMES.include?(block_node.method_name)
+          end
+
+          return unless source_block
+
+          "#{source_block.method_name}#{source_block.send_node.first_argument&.source}"
+        end
+
+        def group_attributes(node)
+          node.arguments.map do |argument|
+            if argument.hash_type?
+              argument.pairs.map(&:source).sort.join(', ')
+            else
+              argument.respond_to?(:value) ? argument.value.to_s : argument.source
+            end
+          end
+        end
       end
     end
   end

data/lib/rubocop/cop/correctors/lambda_literal_to_method_corrector.rb

@@ -14,12 +14,15 @@ module RuboCop
         # Check for unparenthesized args' preceding and trailing whitespaces.
         remove_unparenthesized_whitespace(corrector)
 
-        # Avoid correcting to `lambdado` by inserting whitespace
-        # if none exists before or after the lambda arguments.
-        insert_separating_space(corrector)
+        if block_node.block_type?
+          # Avoid correcting to `lambdado` by inserting whitespace
+          # if none exists before or after the lambda arguments.
+          insert_separating_space(corrector)
+
+          remove_arguments(corrector)
+        end
 
         replace_selector(corrector)
-        remove_arguments(corrector)
 
         replace_delimiters(corrector)
 

data/lib/rubocop/cop/internal_affairs/example_description.rb

@@ -26,9 +26,7 @@ module RuboCop
       #     expect_no_offenses('...')
       #   end
       class ExampleDescription < Base
-        class << self
-          attr_accessor :descriptions
-        end
+        extend AutoCorrector
 
         MSG = 'Description does not match use of `%<method_name>s`.'
 
@@ -39,22 +37,31 @@ module RuboCop
           expect_no_corrections
         ].to_set.freeze
 
-        EXPECT_NO_OFFENSES_INCORRECT_DESCRIPTIONS = [
-          /^(adds|registers|reports|finds) (an? )?offense/,
-          /^(flags|handles|works)\b/
-        ].freeze
+        EXPECT_NO_OFFENSES_DESCRIPTION_MAPPING = {
+          /\A(adds|registers|reports|finds) (an? )?offense/ => 'does not register an offense',
+          /\A(flags|handles|works)\b/ => 'does not register'
+        }.freeze
+
+        EXPECT_OFFENSE_DESCRIPTION_MAPPING = {
+          /\A(does not|doesn't) (register|find|flag|report)/ => 'registers',
+          /\A(does not|doesn't) add (a|an|any )?offense/ => 'registers an offense',
+          /\Aaccepts\b/ => 'registers'
+        }.freeze
 
-        EXPECT_OFFENSE_INCORRECT_DESCRIPTIONS = [
-          /^(does not|doesn't) (register|find|flag|report)/,
-          /^(does not|doesn't) add (a|an|any )?offense/,
-          /^accepts\b/
-        ].freeze
+        EXPECT_NO_CORRECTIONS_DESCRIPTION_MAPPING = {
+          /\A(auto[- ]?)?correct/ => 'does not correct'
+        }.freeze
 
-        EXPECT_NO_CORRECTIONS_INCORRECT_DESCRIPTIONS = [/^(auto[- ]?)?correct/].freeze
+        EXPECT_CORRECTION_DESCRIPTION_MAPPING = {
+          /\b(does not|doesn't) (auto[- ]?)?correct/ => 'autocorrects'
+        }.freeze
 
-        EXPECT_CORRECTION_INCORRECT_DESCRIPTIONS = [
-          /\b(does not|doesn't) (auto[- ]?)?correct/
-        ].freeze
+        EXAMPLE_DESCRIPTION_MAPPING = {
+          expect_no_offenses: EXPECT_NO_OFFENSES_DESCRIPTION_MAPPING,
+          expect_offense: EXPECT_OFFENSE_DESCRIPTION_MAPPING,
+          expect_no_corrections: EXPECT_NO_CORRECTIONS_DESCRIPTION_MAPPING,
+          expect_correction: EXPECT_CORRECTION_DESCRIPTION_MAPPING
+        }.freeze
 
         # @!method offense_example?(node)
         def_node_matcher :offense_example?, <<~PATTERN
@@ -67,21 +74,34 @@ module RuboCop
 
         def on_send(node)
           parent = node.each_ancestor(:block).first
-          return unless parent && (description = offense_example?(parent))
+          return unless parent && (current_description = offense_example?(parent))
 
           method_name = node.method_name
           message = format(MSG, method_name: method_name)
 
-          regexp_group = self.class.const_get("#{method_name}_incorrect_descriptions".upcase)
-          check_description(description, regexp_group, message)
+          description_map = EXAMPLE_DESCRIPTION_MAPPING[method_name]
+          check_description(current_description, description_map, message)
         end
 
         private
 
-        def check_description(description, regexps, message)
-          return unless regexps.any? { |regexp| regexp.match?(string_contents(description)) }
+        def check_description(current_description, description_map, message)
+          description_text = string_contents(current_description)
+          return unless (new_description = correct_description(description_text, description_map))
+
+          add_offense(current_description, message: message) do |corrector|
+            corrector.replace(current_description, "'#{new_description}'")
+          end
+        end
+
+        def correct_description(current_description, description_map)
+          description_map.each do |incorrect_description_pattern, preferred_description|
+            if incorrect_description_pattern.match?(current_description)
+              return current_description.gsub(incorrect_description_pattern, preferred_description)
+            end
+          end
 
-          add_offense(description, message: message)
+          nil
         end
 
         def string_contents(node)

data/lib/rubocop/cop/internal_affairs/redundant_method_dispatch_node.rb

@@ -14,6 +14,12 @@ module RuboCop
       #   node.method_name
       #
       #   # bad
+      #   node.send_node.method?(:method_name)
+      #
+      #   # good
+      #   node.method?(:method_name)
+      #
+      #   # bad
       #   node.send_node.receiver
       #
       #   # good
@@ -24,11 +30,14 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Remove the redundant `send_node`.'
-        RESTRICT_ON_SEND = %i[method_name receiver].freeze
+        RESTRICT_ON_SEND = %i[method_name method? receiver].freeze
 
         # @!method dispatch_method(node)
         def_node_matcher :dispatch_method, <<~PATTERN
-          (send $(send _ :send_node) _)
+          {
+            (send $(send _ :send_node) {:method_name :receiver})
+            (send $(send _ :send_node) :method? _)
+          }
         PATTERN
 
         def on_send(node)

data/lib/rubocop/cop/internal_affairs/useless_message_assertion.rb

@@ -27,6 +27,8 @@ module RuboCop
         PATTERN
 
         def on_new_investigation
+          return if processed_source.blank?
+
           assertions_using_described_class_msg.each { |node| add_offense(node) }
         end
 

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

@@ -32,7 +32,7 @@ module RuboCop
         end
 
         def on_send(node)
-          return unless node.dot? || ampersand_dot?(node)
+          return unless node.dot? || node.safe_navigation?
 
           return correct_style_detected if proper_dot_position?(node)
 
@@ -133,10 +133,6 @@ module RuboCop
           # l.(1) has no selector, so we use the opening parenthesis instead
           node.loc.selector || node.loc.begin
         end
-
-        def ampersand_dot?(node)
-          node.loc.respond_to?(:dot) && node.loc.dot && node.loc.dot.is?('&.')
-        end
       end
     end
   end

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

@@ -3,7 +3,23 @@
 module RuboCop
   module Cop
     module Layout
-      # Enforces empty line after guard clause
+      # Enforces empty line after guard clause.
+      #
+      # This cop allows `# :nocov:` directive after guard clause because
+      # SimpleCov excludes code from the coverage report by wrapping it in `# :nocov:`:
+      #
+      # [source,ruby]
+      # ----
+      # def foo
+      #   # :nocov:
+      #   return if condition
+      #   # :nocov:
+      #   bar
+      # end
+      # ----
+      #
+      # Refer to SimpleCov's documentation for more details:
+      # https://github.com/simplecov-ruby/simplecov#ignoringskipping-code
       #
       # @example
       #
@@ -42,19 +58,22 @@ module RuboCop
 
         MSG = 'Add empty line after guard clause.'
         END_OF_HEREDOC_LINE = 1
+        SIMPLE_DIRECTIVE_COMMENT_PATTERN = /\A# *:nocov:\z/.freeze
 
         def on_if(node)
           return if correct_style?(node)
           return if multiple_statements_on_line?(node)
 
           if node.modifier_form? && (heredoc_node = last_heredoc_argument(node))
-            return if next_line_empty_or_enable_directive_comment?(heredoc_line(node, heredoc_node))
+            if next_line_empty_or_allowed_directive_comment?(heredoc_line(node, heredoc_node))
+              return
+            end
 
             add_offense(heredoc_node.loc.heredoc_end) do |corrector|
               autocorrect(corrector, heredoc_node)
             end
           else
-            return if next_line_empty_or_enable_directive_comment?(node.last_line)
+            return if next_line_empty_or_allowed_directive_comment?(node.last_line)
 
             add_offense(offense_location(node)) { |corrector| autocorrect(corrector, node) }
           end
@@ -70,7 +89,7 @@ module RuboCop
                        end
 
           next_line = node_range.last_line + 1
-          if next_line_enable_directive_comment?(next_line)
+          if next_line_allowed_directive_comment?(next_line)
             node_range = processed_source.comment_at_line(next_line)
           end
 
@@ -88,21 +107,21 @@ module RuboCop
           node.if_branch&.guard_clause?
         end
 
-        def next_line_empty_or_enable_directive_comment?(line)
+        def next_line_empty_or_allowed_directive_comment?(line)
           return true if next_line_empty?(line)
 
           next_line = line + 1
-          next_line_enable_directive_comment?(next_line) && next_line_empty?(next_line)
+          next_line_allowed_directive_comment?(next_line) && next_line_empty?(next_line)
         end
 
         def next_line_empty?(line)
           processed_source[line].blank?
         end
 
-        def next_line_enable_directive_comment?(line)
+        def next_line_allowed_directive_comment?(line)
           return false unless (comment = processed_source.comment_at_line(line))
 
-          DirectiveComment.new(comment).enabled?
+          DirectiveComment.new(comment).enabled? || simplecov_directive_comment?(comment)
         end
 
         def next_line_rescue_or_ensure?(node)
@@ -145,6 +164,8 @@ module RuboCop
 
           if node.if_branch.and_type?
             node.if_branch.children.first
+          elsif use_heredoc_in_condition?(node.condition)
+            node.condition
           else
             node.if_branch.children.last
           end
@@ -161,6 +182,12 @@ module RuboCop
           node.respond_to?(:heredoc?) && node.heredoc?
         end
 
+        def use_heredoc_in_condition?(condition)
+          condition.descendants.any? do |descendant|
+            descendant.respond_to?(:heredoc?) && descendant.heredoc?
+          end
+        end
+
         def offense_location(node)
           if node.loc.respond_to?(:end) && node.loc.end
             node.loc.end
@@ -175,6 +202,12 @@ module RuboCop
 
           parent.begin_type? && parent.single_line?
         end
+
+        # SimpleCov excludes code from the coverage report by wrapping it in `# :nocov:`:
+        # https://github.com/simplecov-ruby/simplecov#ignoringskipping-code
+        def simplecov_directive_comment?(comment)
+          SIMPLE_DIRECTIVE_COMMENT_PATTERN.match?(comment.text)
+        end
       end
     end
   end

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

@@ -25,6 +25,9 @@ module RuboCop
         include Alignment
         include Heredoc
         extend AutoCorrector
+        extend TargetRubyVersion
+
+        minimum_target_ruby_version 2.3
 
         TYPE_MSG = 'Use %<indentation_width>d spaces for indentation in a ' \
                    'heredoc by using `<<~` instead of `%<current_indent_type>s`.'

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

@@ -354,7 +354,7 @@ module RuboCop
           # Don't check indentation if the line doesn't start with the body.
           # For example, lines like "else do_something".
           first_char_pos_on_line = body_node.source_range.source_line =~ /\S/
-          true unless body_node.loc.column == first_char_pos_on_line
+          body_node.loc.column != first_char_pos_on_line
         end
 
         def offending_range(body_node, indentation)

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

@@ -57,7 +57,7 @@ module RuboCop
 
         def on_new_investigation
           processed_source.comments.each do |comment|
-            next unless /\A#+[^#\s=+-]/.match?(comment.text)
+            next unless /\A(?!#\+\+|#--)(#+[^#\s=])/.match?(comment.text)
             next if comment.loc.line == 1 && allowed_on_first_line?(comment)
             next if doxygen_comment_style?(comment)
             next if gemfile_ruby_comment?(comment)

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

@@ -57,16 +57,13 @@ module RuboCop
 
           end_of_first_line = node.source_range.begin_pos - node.source_range.column
 
-          raw_lines(node).each_cons(2) do |raw_line_one, raw_line_two|
+          lines = raw_lines(node)
+          lines.each_cons(2).with_index(node.first_line) do |(raw_line_one, raw_line_two), line_num|
             end_of_first_line += raw_line_one.length
 
-            next unless continuation?(raw_line_one)
+            next unless continuation?(raw_line_one, line_num, node)
 
-            if enforced_style_leading?
-              investigate_leading_style(raw_line_one, raw_line_two, end_of_first_line)
-            else
-              investigate_trailing_style(raw_line_one, raw_line_two, end_of_first_line)
-            end
+            investigate(raw_line_one, raw_line_two, end_of_first_line)
           end
         end
 
@@ -76,6 +73,14 @@ module RuboCop
           processed_source.raw_source.lines[node.first_line - 1, line_range(node).size]
         end
 
+        def investigate(first_line, second_line, end_of_first_line)
+          if enforced_style_leading?
+            investigate_leading_style(first_line, second_line, end_of_first_line)
+          else
+            investigate_trailing_style(first_line, second_line, end_of_first_line)
+          end
+        end
+
         def investigate_leading_style(first_line, second_line, end_of_first_line)
           matches = first_line.match(LEADING_STYLE_OFFENSE)
           return if matches.nil?
@@ -98,8 +103,11 @@ module RuboCop
           end
         end
 
-        def continuation?(line)
-          line.end_with?("\\\n")
+        def continuation?(line, line_num, node)
+          return false unless line.end_with?("\\\n")
+
+          # Ensure backslash isn't part of a token spanning to the next line.
+          node.children.none? { |c| c.first_line == line_num && c.multiline? }
         end
 
         def autocorrect(corrector, offense_range, insert_pos, spaces)

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

@@ -109,7 +109,7 @@ module RuboCop
         # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def comment_ranges(comments)
-          comments.map(&:loc).map(&:expression)
+          comments.map(&:source_range)
         end
 
         def last_line(processed_source)

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

@@ -75,7 +75,7 @@ module RuboCop
         def right_hand_side(send_node)
           dot = send_node.loc.dot
           selector = send_node.loc.selector
-          if send_node.dot? && selector && same_line?(dot, selector)
+          if (send_node.dot? || send_node.safe_navigation?) && selector && same_line?(dot, selector)
             dot.join(selector)
           elsif selector
             selector
@@ -179,7 +179,7 @@ module RuboCop
         # a.b
         #  .c
         def semantic_alignment_base(node, rhs)
-          return unless rhs.source.start_with?('.')
+          return unless rhs.source.start_with?('.', '&.')
 
           node = semantic_alignment_node(node)
           return unless node&.loc&.selector
@@ -204,6 +204,10 @@ module RuboCop
           dot_right_above = get_dot_right_above(node)
           return dot_right_above if dot_right_above
 
+          if (multiline_block_chain_node = find_multiline_block_chain_node(node))
+            return multiline_block_chain_node
+          end
+
           node = first_call_has_a_dot(node)
           return if node.loc.dot.line != node.first_line
 
@@ -219,6 +223,13 @@ module RuboCop
           end
         end
 
+        def find_multiline_block_chain_node(node)
+          return unless (block_node = node.each_descendant(:block, :numblock).first)
+          return unless block_node.multiline? && block_node.parent.call_type?
+
+          block_node.parent
+        end
+
         def first_call_has_a_dot(node)
           # descend to root of method chain
           node = node.receiver while node.receiver

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

@@ -106,9 +106,9 @@ module RuboCop
 
         def suitable_as_single_line?(node)
           !comment_within?(node) &&
-            node.each_descendant(:if, :case, :kwbegin, :def).none? &&
+            node.each_descendant(:if, :case, :kwbegin, :def, :defs).none? &&
             node.each_descendant(:dstr, :str).none? { |n| n.heredoc? || n.value.include?("\n") } &&
-            node.each_descendant(:begin).none? { |b| !b.single_line? }
+            node.each_descendant(:begin, :sym).none? { |b| !b.single_line? }
         end
 
         def convertible_block?(node)
@@ -118,7 +118,9 @@ module RuboCop
         end
 
         def comment_within?(node)
-          processed_source.comments.map(&:loc).map(&:line).any? do |comment_line_number|
+          comment_line_numbers = processed_source.comments.map { |comment| comment.loc.line }
+
+          comment_line_numbers.any? do |comment_line_number|
             comment_line_number >= node.first_line && comment_line_number <= node.last_line
           end
         end

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

@@ -31,7 +31,7 @@ module RuboCop
         private
 
         def whitespace_after_operator?(node)
-          node.receiver.loc.column - node.loc.column > 1
+          node.receiver.source_range.begin_pos - node.source_range.begin_pos > 1
         end
       end
     end