rubocop 1.71.1 → 1.92.0

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

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+begin
+  require 'did_you_mean'
+rescue LoadError
+  nil
+end
+
+module RuboCop
+  module Cop
+    module Lint
+      # Checks for probable typos in constant and method names: a name that
+      # does not resolve anywhere in the project, used in a namespace the
+      # project does define, with a close-named sibling to suggest instead.
+      #
+      # The check is powered by the project-wide index, so it only runs when
+      # `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is installed.
+      # Without the index the cop does nothing.
+      #
+      # Constants are checked only in qualified references (`Foo::Bar`) whose
+      # namespace resolves in the index; bare names cannot be distinguished
+      # from constants provided by gems or the standard library. Methods are
+      # checked only in calls on constant receivers (`Foo.bar`) whose entire
+      # indexed ancestry is resolved, so methods gained through gem classes or
+      # dynamic definitions never produce offenses. In both cases an offense
+      # requires a similarly named alternative to exist — an unknown name
+      # alone is not reported, since the index does not see gems or the
+      # standard library.
+      #
+      # For the same reason, a namespace whose root segment names a gem in the
+      # bundle (`Flipper` for the `flipper` gem) is left alone: a project that
+      # reopens it (`module Flipper; module Adapters; ...`) makes it resolve in
+      # the index, while the members the gem itself defines stay invisible and
+      # would look like typos. Enabling `AllCops/ProjectIndexIncludesGems`
+      # indexes those sources and restores the check.
+      #
+      # Names that appear as symbols or inside string literals in the same
+      # file are never reported, since they usually belong to runtime
+      # definitions the index cannot see (`stub_const`, `const_set`,
+      # `define_method`, and the like).
+      #
+      # @example
+      #   # bad - Services::UserCraetor is not defined, Services::UserCreator is
+      #   Services::UserCraetor.new
+      #
+      #   # good
+      #   Services::UserCreator.new
+      #
+      #   # bad - Report.generate_sumary is not defined, Report.generate_summary is
+      #   Report.generate_sumary
+      #
+      #   # good
+      #   Report.generate_summary
+      #
+      # @example CheckConstants: false
+      #   # good - constant references are not checked
+      #   Services::UserCraetor.new
+      #
+      # @example CheckMethods: false
+      #   # good - method calls are not checked
+      #   Report.generate_sumary
+      #
+      # @example AllowedNames: ['generate_sumary']
+      #   # good - the name is explicitly allowed
+      #   Report.generate_sumary
+      #
+      class NameTypo < Base
+        include ProjectIndexHelp
+
+        CONSTANT_MSG = 'Possible typo: `%<name>s` is not defined in `%<namespace>s`. ' \
+                       'Did you mean `%<suggestion>s`?'
+        METHOD_MSG = 'Possible typo: `%<receiver>s` does not respond to `%<name>s`. ' \
+                     'Did you mean `%<suggestion>s`?'
+
+        METHOD_MEMBER_REGEXP = /#([a-zA-Z_]\w*[?!]?)\(\)\z/.freeze
+        LITERAL_IDENTIFIER_PATTERN = /[a-zA-Z_]\w*[?!]?/.freeze
+
+        def on_const(node)
+          return unless check?('CheckConstants') && checkable_constant?(node)
+
+          suggestion = constant_typo_suggestion(node)
+          return unless suggestion
+
+          message = format(CONSTANT_MSG, name: node.short_name,
+                                         namespace: node.namespace.const_name,
+                                         suggestion: suggestion)
+          add_offense(node.loc.name, message: message)
+        end
+
+        def on_send(node)
+          return unless check?('CheckMethods')
+          return unless node.receiver&.const_type?
+          return if allowed_name?(node.method_name) || defined_check?(node)
+
+          suggestion = method_typo_suggestion(node)
+          return unless suggestion
+
+          message = format(METHOD_MSG, receiver: node.receiver.const_name,
+                                       name: node.method_name,
+                                       suggestion: suggestion)
+          add_offense(node.loc.selector, message: message)
+        end
+        alias on_csend on_send
+
+        def on_new_investigation
+          @literal_names = nil
+          super
+        end
+
+        private
+
+        def check?(key)
+          project_index && defined?(DidYouMean::SpellChecker) && cop_config.fetch(key, true)
+        end
+
+        def checkable_constant?(node)
+          node.namespace&.const_type? &&
+            !allowed_name?(node.short_name) &&
+            !definition_identifier?(node) && !defined_check?(node)
+        end
+
+        def allowed_name?(name)
+          cop_config.fetch('AllowedNames', []).include?(name.to_s)
+        end
+
+        # The last segment of a class, module or constant definition is being
+        # defined, not referenced.
+        def definition_identifier?(node)
+          node.parent&.defined_module
+        end
+
+        # `defined?(Foo::Bar)` probes whether a name exists; unknown names
+        # there are deliberate.
+        def defined_check?(node)
+          node.each_ancestor(:defined?).any?
+        end
+
+        def constant_typo_suggestion(node)
+          namespace = resolve_constant_in_index(node.namespace)
+          return nil unless namespace.is_a?(Rubydex::Namespace)
+          return nil if namespace.find_member(node.short_name.to_s)
+          return nil unless complete_index_members?(namespace)
+          return nil if literal_names.include?(node.short_name.to_s)
+
+          spell_check(node.short_name, constant_member_names(namespace))
+        rescue StandardError
+          nil
+        end
+
+        # Whether the index can be trusted to list everything the namespace
+        # defines. A name missing from an incomplete member list is not
+        # evidence of a typo, so both gaps have to be ruled out first:
+        # an ancestor that does not resolve may contribute the name, and so
+        # may a gem that reopens the namespace.
+        def complete_index_members?(declaration)
+          fully_resolved_index_ancestry?(declaration) && !gem_owned_namespace?(declaration)
+        end
+
+        # Whether the namespace's root segment names a gem in the bundle,
+        # which is then free to define members the index never sees: gem
+        # sources are only indexed when `AllCops/ProjectIndexIncludesGems`
+        # is enabled. A project that reopens such a namespace to add its own
+        # members (`module Flipper; module Adapters; ...`) makes it resolve
+        # in the index while most of what it holds stays invisible.
+        def gem_owned_namespace?(declaration)
+          return false if config.for_all_cops['ProjectIndexIncludesGems']
+
+          root = declaration.name.to_s.split('::').first.to_s
+          bundled_gem_namespaces.include?(root.downcase)
+        end
+
+        # Gem names normalized towards the constant they conventionally
+        # provide: `flipper` for `Flipper`, `activerecord` for `ActiveRecord`.
+        def bundled_gem_namespaces
+          @bundled_gem_namespaces ||= bundled_gem_names.to_set { |name| name.delete('-_').downcase }
+        end
+
+        # The bundle's gems except those sourced from a local path, whose code
+        # lives in the project and is indexed like the rest of it — among them
+        # the project's own gem, which its lockfile lists in the `PATH` section.
+        def bundled_gem_names
+          (config.gem_versions_in_target || {}).keys - (config.path_sourced_gems_in_target || [])
+        end
+
+        # Writers are indexed under the reader's name, so setter calls are
+        # verified and spell-checked through the base name.
+        def method_typo_suggestion(node)
+          setter = setter_call?(node)
+          base = setter ? node.method_name.to_s.delete_suffix('=') : node.method_name.to_s
+
+          declaration = unknown_method_owner(node, base)
+          return nil unless declaration
+          return nil if literal_names.include?(base)
+
+          suggestion = spell_check(base, method_member_names(declaration))
+          suggestion && setter ? "#{suggestion}=" : suggestion
+        rescue StandardError
+          nil
+        end
+
+        # The receiver's declaration when it resolves in the index, everything
+        # it can inherit or be reopened with is visible there, and the method
+        # is not found — nil otherwise.
+        def unknown_method_owner(node, base)
+          declaration = resolve_constant_in_index(node.receiver)
+          return nil unless declaration.is_a?(Rubydex::Namespace)
+          return nil if responds_in_index?(declaration, node.method_name.to_s, base)
+          return nil unless fully_resolved_index_ancestry?(declaration)
+          return nil if gem_owned_namespace?(declaration)
+
+          declaration
+        end
+
+        def setter_call?(node)
+          node.assignment_method? && !node.operator_method?
+        end
+
+        def responds_in_index?(declaration, name, base)
+          # Instance methods of a module are also callable on the module
+          # itself when exposed with `module_function`.
+          [name, base].uniq.any? do |candidate|
+            member_name = "#{candidate}()"
+            indexed_singleton_member(declaration, member_name) ||
+              declaration.find_member(member_name)
+          end
+        end
+
+        # Names mentioned as symbols or inside string literals in the current
+        # file belong to runtime definitions (`stub_const`, `const_set`,
+        # `define_method`) that the index cannot see.
+        def literal_names
+          @literal_names ||=
+            processed_source.ast.each_descendant(:sym, :str)
+                            .with_object(Set.new) do |literal, names|
+              if literal.sym_type?
+                names << literal.value.to_s
+              else
+                # `scan` raises on binary string literals with invalid byte sequences.
+                value = literal.value
+                value = value.scrub unless value.valid_encoding?
+                value.scan(LITERAL_IDENTIFIER_PATTERN) { |token| names << token }
+              end
+            end
+        end
+
+        def constant_member_names(namespace)
+          namespace.members.filter_map do |member|
+            name = member.name
+            name.split('::').last unless name.include?('#') || name.include?('<')
+          end
+        end
+
+        def method_member_names(declaration)
+          scopes = declaration.ancestors.filter_map { |ancestor| indexed_singleton_of(ancestor) }
+          scopes << declaration
+
+          scopes.flat_map do |scope|
+            scope.members.filter_map { |member| member.name[METHOD_MEMBER_REGEXP, 1] }
+          end
+        end
+
+        def spell_check(name, dictionary)
+          return nil if dictionary.empty?
+
+          DidYouMean::SpellChecker.new(dictionary: dictionary.uniq).correct(name.to_s).first
+        end
+      end
+    end
+  end
+end

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

@@ -95,10 +95,10 @@ module RuboCop
         MSG = 'Method definitions must not be nested. Use `lambda` instead.'
 
         def on_def(node)
-          subject, = *node # rubocop:disable InternalAffairs/NodeDestructuring
+          subject, = *node # rubocop:disable InternalAffairs/NodeDestructuring -- the first child differs between `def` and `defs`
           return if node.defs_type? && allowed_subject_type?(subject)
 
-          def_ancestor = node.each_ancestor(:def, :defs).first
+          def_ancestor = node.each_ancestor(:any_def).first
           return unless def_ancestor
 
           within_scoping_def =

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

@@ -31,6 +31,7 @@ module RuboCop
           end
         end
         alias on_numblock on_block
+        alias on_itblock on_block
 
         private
 
@@ -39,6 +40,7 @@ module RuboCop
           {
             (block (call _recv {:reduce :inject} !sym) _blockargs $(begin ...))
             (numblock (call _recv {:reduce :inject} !sym) _argscount $(begin ...))
+            (itblock (call _recv {:reduce :inject} !sym) _argscount $(begin ...))
           }
         PATTERN
 

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

@@ -41,12 +41,32 @@ module RuboCop
         def on_lvasgn(node)
           node.each_node(:kwbegin) do |kwbegin_node|
             kwbegin_node.each_node(:return) do |return_node|
+              next if return_from_inner_scope?(return_node, kwbegin_node)
+
               add_offense(return_node)
             end
           end
         end
+        alias on_ivasgn on_lvasgn
+        alias on_cvasgn on_lvasgn
+        alias on_gvasgn on_lvasgn
+        alias on_casgn on_lvasgn
         alias on_or_asgn on_lvasgn
         alias on_op_asgn on_lvasgn
+
+        private
+
+        # A `return` inside a nested method definition or lambda within the
+        # `begin..end` returns from that inner scope rather than the assignment
+        # context, so it is not an offense. A `return` inside a plain block (or
+        # `proc`) does propagate out, so it remains an offense.
+        def return_from_inner_scope?(return_node, kwbegin_node)
+          return_node.each_ancestor do |ancestor|
+            break if ancestor == kwbegin_node
+            return true if ancestor.any_def_type? || (ancestor.any_block_type? && ancestor.lambda?)
+          end
+          false
+        end
       end
     end
   end

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

@@ -12,7 +12,7 @@ module RuboCop
       # always sort the list.
       #
       # `Dir.glob` and `Dir[]` sort globbed results by default in Ruby 3.0.
-      # So all bad cases are acceptable when Ruby 3.0 or higher are used.
+      # So all bad cases are acceptable when Ruby 3.0 or higher is used.
       #
       # NOTE: This cop will be deprecated and removed when supporting only Ruby 3.0 and higher.
       #
@@ -65,7 +65,9 @@ module RuboCop
 
         maximum_target_ruby_version 2.7
 
-        def on_block(node)
+        # NOTE: itblock is not handled because this cop is limited to Ruby <= 2.7
+        # via `maximum_target_ruby_version`, so itblock nodes (Ruby 3.4+) are never encountered.
+        def on_block(node) # rubocop:disable InternalAffairs/ItblockHandler -- limited to Ruby <= 2.7, where `it` blocks do not exist
           return unless node.body
           return unless unsorted_dir_loop?(node.send_node)
 

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

@@ -46,7 +46,7 @@ module RuboCop
         def on_return(return_node)
           return if return_value?(return_node)
 
-          return_node.each_ancestor(:block, :def, :defs) do |node|
+          return_node.each_ancestor(:any_block, :any_def) do |node|
             break if scoped_node?(node)
 
             # if a proc is passed to `Module#define_method` or
@@ -54,7 +54,7 @@ module RuboCop
             # non-local exit error
             break if define_method?(node.send_node)
 
-            next unless node.arguments?
+            next if node.argument_list.empty?
 
             if chained_send?(node.send_node)
               add_offense(return_node.loc.keyword)
@@ -66,7 +66,7 @@ module RuboCop
         private
 
         def scoped_node?(node)
-          node.type?(:def, :defs) || node.lambda?
+          node.any_def_type? || node.lambda?
         end
 
         def return_value?(return_node)
@@ -74,7 +74,7 @@ module RuboCop
         end
 
         # @!method chained_send?(node)
-        def_node_matcher :chained_send?, '(send !nil? ...)'
+        def_node_matcher :chained_send?, '(call !nil? ...)'
 
         # @!method define_method?(node)
         def_node_matcher :define_method?, <<~PATTERN

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

@@ -3,9 +3,9 @@
 module RuboCop
   module Cop
     module Lint
-      # Warns the usage of unsafe number conversions. Unsafe
-      # number conversion can cause unexpected error if auto type conversion
-      # fails. Cop prefer parsing with number class instead.
+      # Warns against the usage of unsafe number conversions. Unsafe
+      # number conversion can cause an unexpected error if auto type conversion
+      # fails. The cop prefers parsing with a number class instead.
       #
       # Conversion with `Integer`, `Float`, etc. will raise an `ArgumentError`
       # if given input that is not numeric (eg. an empty string), whereas
@@ -14,10 +14,10 @@ module RuboCop
       # always correct to raise if a value is not numeric.
       #
       # NOTE: Some values cannot be converted properly using one of the `Kernel`
-      # method (for instance, `Time` and `DateTime` values are allowed by this
+      # methods (for instance, `Time` and `DateTime` values are allowed by this
       # cop by default). Similarly, Rails' duration methods do not work well
       # with `Integer()` and can be allowed with `AllowedMethods`. By default,
-      # there are no methods to allowed.
+      # there are no allowed methods.
       #
       # @safety
       #   Autocorrection is unsafe because it is not guaranteed that the
@@ -66,7 +66,7 @@ module RuboCop
       #   # good
       #   10.minutes.to_i
       #
-      # @example IgnoredClasses: [Time, DateTime] (default)
+      # @example AllowedClasses: [Time, DateTime] (default)
       #
       #   # good
       #   Time.now.to_datetime.to_i
@@ -117,11 +117,11 @@ module RuboCop
 
             message = format(
               MSG,
-              current: "#{receiver.source}.#{to_method}",
+              current: current_method(node, receiver, to_method),
               corrected_method: correct_method(node, receiver)
             )
             add_offense(node, message: message) do |corrector|
-              next if part_of_ignored_node?(node)
+              next if safe_navigation?(node) || part_of_ignored_node?(node)
 
               corrector.replace(node, correct_method(node, node.receiver))
 
@@ -132,7 +132,7 @@ module RuboCop
 
         def handle_as_symbol(node)
           to_method_symbol(node) do |receiver, sym_node, to_method|
-            next if receiver.nil? || !node.arguments.one?
+            next if receiver.nil? || !node.arguments.one? || node.operator_method?
 
             message = format(
               MSG,
@@ -156,13 +156,22 @@ module RuboCop
           "{ |i| #{body} }"
         end
 
+        def current_method(node, receiver, to_method)
+          operator = node.csend_type? ? '&.' : '.'
+          "#{receiver.source}#{operator}#{to_method}"
+        end
+
         def remove_parentheses(corrector, node)
           corrector.replace(node.loc.begin, ' ')
           corrector.remove(node.loc.end)
         end
 
+        def safe_navigation?(node)
+          node.csend_type? || node.each_descendant(:csend).any?
+        end
+
         def allow_receiver?(receiver)
-          if receiver.numeric_type? || (receiver.send_type? &&
+          if receiver.numeric_type? || (receiver.call_type? &&
             (conversion_method?(receiver.method_name) ||
             allowed_method_name?(receiver.method_name)))
             true
@@ -188,7 +197,7 @@ module RuboCop
         end
 
         def ignored_classes
-          cop_config.fetch('IgnoredClasses', [])
+          cop_config.fetch('AllowedClasses', [])
         end
 
         def ignored_class?(name)

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

@@ -16,7 +16,7 @@ module RuboCop
       #   ruby 3.0.0p0 (2020-12-25 revision 95aff21468) [x86_64-darwin19]
       #   -e:1: _1 is reserved for numbered parameter
       #
-      # NOTE: The parametered parameters are from `_1` to `_9`. This cop checks `_0`, and over `_10`
+      # NOTE: The numbered parameters are from `_1` to `_9`. This cop checks `_0`, and over `_10`
       # as well to prevent confusion.
       #
       # @example

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

@@ -15,6 +15,13 @@ module RuboCop
       # can't determine the type of `x`. If `x` is an `Array` or `String`, it doesn't perform
       # a numeric operation.
       #
+      # @safety
+      #   This cop is unsafe because the autocorrection drops the operands, which
+      #   discards any side effects of evaluating them and can change behavior when
+      #   the result is not actually constant. For example, `x / x` raises
+      #   `ZeroDivisionError` when `x` is `0`, and returns `Float::NAN` (not `1`)
+      #   when `x` is `0.0`; replacing it with `1` silences that.
+      #
       # @example
       #
       #   # bad
@@ -45,6 +52,7 @@ module RuboCop
       #
       class NumericOperationWithConstantResult < Base
         extend AutoCorrector
+
         MSG = 'Numeric operation with a constant result detected.'
         RESTRICT_ON_SEND = %i[* / **].freeze
 
@@ -57,6 +65,9 @@ module RuboCop
                          '(op-asgn (lvasgn $_lhs) $_operation ({int lvar} $_rhs))'
 
         def on_send(node)
+          # Safe navigation short-circuits to `nil` when the receiver is `nil`, so the
+          # result is not constant and replacing it with `0`/`1` would change behavior.
+          return if node.csend_type?
           return unless (lhs, operation, rhs = operation_with_constant_result?(node))
           return unless (result = constant_result?(lhs, operation, rhs))
 

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

@@ -30,7 +30,7 @@ module RuboCop
           return unless node.lhs&.casgn_type?
 
           add_offense(node.loc.operator) do |corrector|
-            next if node.each_ancestor(:def, :defs).any?
+            next if node.each_ancestor(:any_def).any?
 
             corrector.replace(node.loc.operator, '=')
           end

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

@@ -38,23 +38,23 @@ module RuboCop
         def on_new_investigation
           return if processed_source.buffer.source.empty?
 
-          encoding_line, frozen_string_literal_line = magic_comment_lines
+          encoding_line, other_magic_comment_line = magic_comment_lines
 
-          return unless encoding_line && frozen_string_literal_line
-          return if encoding_line < frozen_string_literal_line
+          return unless encoding_line && other_magic_comment_line
+          return if encoding_line < other_magic_comment_line
 
           range = processed_source.buffer.line_range(encoding_line + 1)
 
           add_offense(range) do |corrector|
-            autocorrect(corrector, encoding_line, frozen_string_literal_line)
+            autocorrect(corrector, encoding_line, other_magic_comment_line)
           end
         end
 
         private
 
-        def autocorrect(corrector, encoding_line, frozen_string_literal_line)
+        def autocorrect(corrector, encoding_line, other_magic_comment_line)
           range1 = processed_source.buffer.line_range(encoding_line + 1)
-          range2 = processed_source.buffer.line_range(frozen_string_literal_line + 1)
+          range2 = processed_source.buffer.line_range(other_magic_comment_line + 1)
 
           corrector.replace(range1, range2.source)
           corrector.replace(range2, range1.source)
@@ -66,7 +66,7 @@ module RuboCop
           leading_magic_comments.each.with_index do |comment, index|
             if comment.encoding_specified?
               lines[0] = index
-            elsif comment.frozen_string_literal_specified?
+            elsif comment.valid?
               lines[1] = index
             end
 

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

@@ -53,6 +53,8 @@ module RuboCop
         end
 
         def after_send(node)
+          return if backrefs_unaffected?(node)
+
           @valid_ref = nil
 
           if regexp_first_argument?(node)
@@ -111,6 +113,19 @@ module RuboCop
                        end
         end
 
+        # A call such as `hash[:key]` or `array[0]` cannot involve a regexp match:
+        # a non-string literal cannot act as a pattern (whereas `sub`, `gsub`,
+        # and `match` treat a string one as a pattern and do set backreferences),
+        # and `$~` is frame-local, so a user-defined method cannot change
+        # the caller's backreferences either.
+        def backrefs_unaffected?(send_node)
+          first_argument = send_node.first_argument
+          return false unless first_argument&.basic_literal?
+          return false if first_argument.str_type?
+
+          !regexp_receiver?(send_node)
+        end
+
         def regexp_first_argument?(send_node)
           send_node.first_argument&.regexp_type? \
             && REGEXP_ARGUMENT_METHODS.include?(send_node.method_name)
@@ -119,10 +134,6 @@ module RuboCop
         def regexp_receiver?(send_node)
           send_node.receiver&.regexp_type?
         end
-
-        def nth_ref_receiver?(send_node)
-          send_node.receiver&.nth_ref_type?
-        end
       end
     end
   end

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

@@ -46,13 +46,29 @@ module RuboCop
 
         def valid_first_argument?(first_arg)
           first_arg.operator_keyword? || first_arg.hash_type? || ternary_expression?(first_arg) ||
-            compound_range?(first_arg)
+            compound_range?(first_arg) || invalid_bare_argument?(first_arg)
         end
 
         def compound_range?(first_arg)
           first_arg.range_type? && first_arg.parenthesized_call?
         end
 
+        def invalid_bare_argument?(node)
+          node = node.children.first while node&.begin_type? && node.children.one?
+          return false unless node
+
+          keyword_operator?(node) || modifier_expression?(node)
+        end
+
+        def keyword_operator?(node)
+          (node.operator_keyword? && node.semantic_operator?) ||
+            node.rescue_type? || (node.send_type? && node.prefix_not?)
+        end
+
+        def modifier_expression?(node)
+          node.type?(:if, :while, :until) && node.modifier_form?
+        end
+
         def chained_calls?(node)
           first_argument = node.first_argument
           first_argument.call_type? && (node.children.last&.children&.count || 0) > 1
@@ -63,19 +79,9 @@ module RuboCop
         end
 
         def spaces_before_left_parenthesis(node)
-          receiver = node.receiver
-          receiver_length = if receiver
-                              receiver.source.length
-                            else
-                              0
-                            end
-          without_receiver = node.source[receiver_length..]
-
-          # Escape question mark if any.
-          method_regexp = Regexp.escape(node.method_name)
-
-          match = without_receiver.match(/^\s*&?\.?\s*#{method_regexp}(\s+)\(/)
-          match ? match.captures[0].length : 0
+          return 0 if node.parenthesized? || !node.first_argument.source.start_with?('(')
+
+          node.first_argument.source_range.begin_pos - node.loc.selector.end_pos
         end
 
         def space_range(expr, space_length)