rubocop 1.81.7 → 1.82.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8acfafa4ed4b94c367e6ef95c84d2d02f01222a1e8a813790948977476f34456
-  data.tar.gz: 0d2ad56c4a81da58046a098351606bfb8314f09f9e5f946ad1dd825aa70fe0f7
+  metadata.gz: 9dfdd0a2943006435a98725498ab85032b82d1cff547cd0bed007a250e56aca4
+  data.tar.gz: c6a9e601a1e7858282d835dc00cd0f065ab3bc43de633988877dae6422f85f71
 SHA512:
-  metadata.gz: ae4edea22ca7511df39ec99591df3d537bfd3fa8974d5bb461d2b1c674b48f15296f22c81b1cd9329719a68b0d3f8d36442eaa5742cbf8e0974c6e3e2e56e29c
-  data.tar.gz: ffce467cec50d2ed0ef7b312a15dd17e9b7fd1622b70528d12f0cfe16056ae3b5111f2d360b4e855ea5811befd092a306ff56ad091b89a6050f3354f3db205a4
+  metadata.gz: e19cc58194cf953813d3e3bf0d3bfa7d976f30127008ba84473b08cdcba188a4f73ac102baea188dfa463723b15fc768a3b7152306d5fcb5a5b7b7265e031ad2
+  data.tar.gz: 26ed5927b0b375947c553a46434c6a58a63022c928b84b03ff1b44a8a74eee6c8cb29342262df28fcca223e194257d7e9fe7a06fb422d42e0805287380830743

data/README.md

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

data/config/default.yml

@@ -1102,7 +1102,7 @@ Layout/LineLength:
   StyleGuide: '#max-line-length'
   Enabled: true
   VersionAdded: '0.25'
-  VersionChanged: '1.69'
+  VersionChanged: '1.82'
   Max: 120
   AllowHeredoc: true
   # To make it possible to copy or click on URIs in the code, we allow lines
@@ -1112,9 +1112,12 @@ Layout/LineLength:
   URISchemes:
     - http
     - https
-  # The IgnoreCopDirectives option causes the LineLength rule to ignore cop
+  # The AllowRBSInlineAnnotation option makes LineLength allow RBS::Inline annotations
+  # such as `#: (?date: Date) -> Foo` when calculating line length.
+  AllowRBSInlineAnnotation: false
+  # The AllowCopDirectives option causes the LineLength rule to ignore cop
   # directives like '# rubocop: enable ...' when calculating a line's length.
-  IgnoreCopDirectives: true
+  AllowCopDirectives: true
   # The AllowedPatterns option is a list of !ruby/regexp and/or string
   # elements. Strings will be converted to Regexp objects. A line that matches
   # any regular expression listed in this option will be ignored by LineLength.
@@ -2669,7 +2672,10 @@ Lint/UselessNumericOperation:
 Lint/UselessOr:
   Description: 'Checks for useless OR expressions.'
   Enabled: pending
+  SafeAutoCorrect: false
+  AutoCorrect: contextual
   VersionAdded: '1.76'
+  VersionChanged: '1.82'
 
 Lint/UselessRescue:
   Description: 'Checks for useless `rescue`s.'
@@ -3281,7 +3287,7 @@ Style/Alias:
 
 Style/AmbiguousEndlessMethodDefinition:
   Description: 'Checks for endless methods inside operators of lower precedence.'
-  StyleGuide: '#ambiguous-endless-method-defintions'
+  StyleGuide: '#ambiguous-endless-method-definitions'
   Enabled: pending
   VersionAdded: '1.68'
 
@@ -3525,9 +3531,11 @@ Style/BlockDelimiters:
   BracesRequiredMethods: []
 
 Style/CaseEquality:
-  Description: 'Avoid explicit use of the case equality operator(===).'
+  Description: 'Avoid explicit use of the case equality operator (`===`).'
   StyleGuide: '#no-case-equality'
   Enabled: true
+  References:
+    - 'https://docs.rubocop.org/rubocop-performance/cops_performance.html#performanceregexpmatch'
   VersionAdded: '0.9'
   VersionChanged: '0.89'
   # If `AllowOnConstant` option is enabled, the cop will ignore violations when the receiver of
@@ -4625,6 +4633,7 @@ Style/MethodCallWithArgsParentheses:
   AllowedMethods: []
   AllowedPatterns: []
   IncludedMacros: []
+  IncludedMacroPatterns: []
   AllowParenthesesInMultilineCall: false
   AllowParenthesesInChaining: false
   AllowParenthesesInCamelCaseMethod: false
@@ -4735,6 +4744,11 @@ Style/ModuleFunction:
   Autocorrect: false
   SafeAutoCorrect: false
 
+Style/ModuleMemberExistenceCheck:
+  Description: 'Checks for usage of `Module` methods returning arrays that can be replaced with equivalent predicates.'
+  Enabled: pending
+  VersionAdded: '1.82'
+
 Style/MultilineBlockChain:
   Description: 'Avoid multi-line chains of blocks.'
   StyleGuide: '#single-line-blocks'
@@ -5222,6 +5236,8 @@ Style/RedundantArgument:
     exit: true
     # Kernel.#exit!
     exit!: false
+    # String#to_i
+    to_i: 10
     # String#split
     split: ' '
     # String#chomp

data/config/obsoletion.yml

@@ -145,6 +145,10 @@ changed_parameters:
   - cops: Layout/CaseIndentation
     parameters: IndentWhenRelativeTo
     alternative: EnforcedStyle
+  - cops: Layout/LineLength
+    parameters: IgnoreCopDirectives
+    alternative: AllowCopDirectives
+    severity: warning
   - cops:
       - Lint/BlockAlignment
       - Layout/BlockAlignment

data/lib/rubocop/cli.rb

@@ -66,7 +66,7 @@ module RuboCop
       STATUS_INTERRUPTED
     rescue Finished
       STATUS_SUCCESS
-    rescue OptionParser::InvalidOption => e
+    rescue OptionParser::ParseError => e
       warn e.message
       warn 'For usage information, use --help'
       STATUS_ERROR
@@ -183,6 +183,7 @@ module RuboCop
       ConfigLoader.enable_pending_cops = @options[:enable_pending_cops]
       ConfigLoader.ignore_parent_exclusion = @options[:ignore_parent_exclusion]
       ConfigLoader.ignore_unrecognized_cops = @options[:ignore_unrecognized_cops]
+      ConfigLoader.cache_root = ResultCache.cache_root(@config_store, @options[:cache_root])
     end
 
     def set_options_to_pending_cops_reporter

data/lib/rubocop/comment_config.rb

@@ -34,6 +34,7 @@ module RuboCop
     def initialize(processed_source)
       @processed_source = processed_source
       @no_directives = !processed_source.raw_source.include?('rubocop')
+      @stack = []
     end
 
     def cop_enabled_at_line?(cop, line_number)
@@ -93,16 +94,23 @@ module RuboCop
       end
     end
 
-    def analyze # rubocop:todo Metrics/AbcSize
+    def analyze # rubocop:todo Metrics/AbcSize, Metrics/MethodLength
       return {} if @no_directives
 
       analyses = Hash.new { |hash, key| hash[key] = CopAnalysis.new([], nil) }
       inject_disabled_cops_directives(analyses)
 
       each_directive do |directive|
-        directive.cop_names.each do |cop_name|
-          cop_name = qualified_cop_name(cop_name)
-          analyses[cop_name] = analyze_cop(analyses[cop_name], directive)
+        if directive.push?
+          @stack.push(snapshot_analyses(analyses))
+          apply_push_args(analyses, directive)
+        elsif directive.pop?
+          pop_state(analyses, directive.line_number) if @stack.any?
+        else
+          directive.cop_names.each do |cop_name|
+            cop_name = qualified_cop_name(cop_name)
+            analyses[cop_name] = analyze_cop(analyses[cop_name], directive)
+          end
         end
       end
 
@@ -112,6 +120,51 @@ module RuboCop
       end
     end
 
+    def snapshot_analyses(analyses)
+      analyses.transform_values { |a| CopAnalysis.new(a.line_ranges.dup, a.start_line_number) }
+    end
+
+    def pop_state(analyses, pop_line)
+      analyses.each do |cop_name, analysis|
+        next unless analysis.start_line_number
+
+        analyses[cop_name] = CopAnalysis.new(
+          analysis.line_ranges + [analysis.start_line_number...pop_line], nil
+        )
+      end
+
+      @stack.pop.each do |cop_name, saved_analysis|
+        current = analyses[cop_name]
+        new_start = saved_analysis.start_line_number ? pop_line : nil
+        analyses[cop_name] = CopAnalysis.new(current.line_ranges, new_start)
+      end
+    end
+
+    def apply_push_args(analyses, directive)
+      directive.push_args.each do |operation, cop_names|
+        cop_names.each do |cop_name|
+          apply_cop_operation(analyses, operation, qualified_cop_name(cop_name),
+                              directive.line_number)
+        end
+      end
+    end
+
+    def apply_cop_operation(analyses, operation, cop_name, line)
+      analysis = analyses[cop_name]
+      start_line = analysis.start_line_number
+
+      case operation
+      when '+' # Enable cop
+        return unless start_line
+
+        analyses[cop_name] = CopAnalysis.new(analysis.line_ranges + [start_line..line], nil)
+      when '-' # Disable cop
+        return if start_line
+
+        analyses[cop_name] = CopAnalysis.new(analysis.line_ranges, line)
+      end
+    end
+
     def inject_disabled_cops_directives(analyses)
       registry.disabled(config).each do |cop|
         analyses[cop.cop_name] = analyze_cop(
@@ -136,29 +189,21 @@ module RuboCop
       return analysis unless directive.disabled?
 
       line = directive.line_number
-      start_line = analysis.start_line_number
-
-      CopAnalysis.new(analysis.line_ranges + [(line..line)], start_line)
+      CopAnalysis.new(analysis.line_ranges + [(line..line)], analysis.start_line_number)
     end
 
     def analyze_disabled(analysis, directive)
       line = directive.line_number
       start_line = analysis.start_line_number
-
-      # Cop already disabled on this line, so we end the current disabled
-      # range before we start a new range.
-      return CopAnalysis.new(analysis.line_ranges + [start_line..line], line) if start_line
-
-      CopAnalysis.new(analysis.line_ranges, line)
+      new_ranges = start_line ? analysis.line_ranges + [start_line..line] : analysis.line_ranges
+      CopAnalysis.new(new_ranges, line)
     end
 
     def analyze_rest(analysis, directive)
       line = directive.line_number
       start_line = analysis.start_line_number
-
-      return CopAnalysis.new(analysis.line_ranges + [start_line..line], nil) if start_line
-
-      CopAnalysis.new(analysis.line_ranges, nil)
+      new_ranges = start_line ? analysis.line_ranges + [start_line..line] : analysis.line_ranges
+      CopAnalysis.new(new_ranges, nil)
     end
 
     def cop_line_ranges(analysis)

data/lib/rubocop/config_loader.rb

@@ -23,7 +23,7 @@ module RuboCop
       include FileFinder
 
       attr_accessor :debug, :ignore_parent_exclusion, :disable_pending_cops, :enable_pending_cops,
-                    :ignore_unrecognized_cops
+                    :ignore_unrecognized_cops, :cache_root
       attr_writer :default_configuration
       attr_reader :loaded_plugins, :loaded_features
 
@@ -38,6 +38,7 @@ module RuboCop
         @enable_pending_cops = nil
         @ignore_parent_exclusion = nil
         @ignore_unrecognized_cops = nil
+        @cache_root = nil
         FileFinder.root_level = nil
       end
 

data/lib/rubocop/config_loader_resolver.rb

@@ -246,7 +246,7 @@ module RuboCop
     def inherited_file(path, inherit_from, file)
       if PathUtil.remote_file?(inherit_from)
         # A remote configuration, e.g. `inherit_from: http://example.com/rubocop.yml`.
-        RemoteConfig.new(inherit_from, File.dirname(path))
+        RemoteConfig.new(inherit_from, ConfigLoader.cache_root)
       elsif Pathname.new(inherit_from).absolute?
         # An absolute path to a config, e.g. `inherit_from: /Users/me/rubocop.yml`.
         # The path may come from `inherit_gem` option, where a gem name is expanded
@@ -256,7 +256,7 @@ module RuboCop
       elsif file.is_a?(RemoteConfig)
         # A path relative to a URL, e.g. `inherit_from: configs/default.yml`
         # in a config included with `inherit_from: http://example.com/rubocop.yml`
-        file.inherit_from_remote(inherit_from, path)
+        file.inherit_from_remote(inherit_from)
       else
         # A local relative path, e.g. `inherit_from: default.yml`
         print 'Inheriting ' if ConfigLoader.debug?

data/lib/rubocop/cop/autocorrect_logic.rb

@@ -90,6 +90,8 @@ module RuboCop
       end
 
       def line_with_eol_comment_too_long?(range)
+        return false unless max_line_length
+
         (range.source_line + eol_comment).length > max_line_length
       end
 
@@ -133,6 +135,8 @@ module RuboCop
       end
 
       def max_line_length
+        return unless config.cop_enabled?('Layout/LineLength')
+
         config.for_cop('Layout/LineLength')['Max'] || 120
       end
 

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

@@ -43,8 +43,7 @@ module RuboCop
         def on_new_investigation
           return if processed_source.blank?
 
-          gem_declarations(processed_source.ast)
-            .each_cons(2) do |previous, current|
+          gem_declarations(processed_source.ast).each_cons(2) do |previous, current|
             next unless consecutive_lines?(previous, current)
             next unless case_insensitive_out_of_order?(gem_name(current), gem_name(previous))
 

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

@@ -76,9 +76,7 @@ module RuboCop
         #   nil.
         # - The source map of `__FILE__` responds to neither :begin nor :end.
         def delimited_string_literal?(node)
-          loc = node.location
-
-          loc.respond_to?(:begin) && loc.begin && loc.respond_to?(:end) && loc.end
+          node.loc?(:begin) && node.loc?(:end)
         end
 
         def block_comment_within?(expr)

data/lib/rubocop/cop/gemspec/ordered_dependencies.rb

@@ -69,8 +69,7 @@ module RuboCop
         def on_new_investigation
           return if processed_source.blank?
 
-          dependency_declarations(processed_source.ast)
-            .each_cons(2) do |previous, current|
+          dependency_declarations(processed_source.ast).each_cons(2) do |previous, current|
             next unless consecutive_lines?(previous, current)
             next unless case_insensitive_out_of_order?(gem_name(current), gem_name(previous))
             next unless get_dependency_name(previous) == get_dependency_name(current)

data/lib/rubocop/cop/gemspec/ruby_version_globals_usage.rb

@@ -3,8 +3,8 @@
 module RuboCop
   module Cop
     module Gemspec
-      # Checks that `RUBY_VERSION` constant is not used in gemspec.
-      # Using `RUBY_VERSION` is dangerous because value of the
+      # Checks that `RUBY_VERSION` and `Ruby::VERSION` constants are not used in gemspec.
+      # Using `RUBY_VERSION` and `Ruby::VERSION` are dangerous because value of the
       # constant is determined by `rake release`.
       # It's possible to have dependency based on ruby version used
       # to execute `rake release` and not user's ruby version.
@@ -28,15 +28,20 @@ module RuboCop
       class RubyVersionGlobalsUsage < Base
         include GemspecHelp
 
-        MSG = 'Do not use `RUBY_VERSION` in gemspec file.'
+        MSG = 'Do not use `%<ruby_version>s` in gemspec file.'
 
         # @!method ruby_version?(node)
-        def_node_matcher :ruby_version?, '(const {cbase nil?} :RUBY_VERSION)'
+        def_node_matcher :ruby_version?, <<~PATTERN
+          {
+            (const {cbase nil?} :RUBY_VERSION)
+            (const (const {cbase nil?} :Ruby) :VERSION)
+          }
+        PATTERN
 
         def on_const(node)
           return unless gem_spec_with_ruby_version?(node)
 
-          add_offense(node)
+          add_offense(node, message: format(MSG, ruby_version: node.source))
         end
 
         private

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

@@ -9,6 +9,12 @@ module RuboCop
       #
       # @example
       #   # bad
+      #   node.loc.respond_to?(:begin)
+      #
+      #   # good
+      #   node.loc?(:begin)
+      #
+      #   # bad
       #   node.loc.respond_to?(:begin) && node.loc.begin
       #
       #   # good
@@ -29,7 +35,16 @@ module RuboCop
       class LocationExists < Base
         extend AutoCorrector
 
-        MSG = 'Use `%<replacement>s` instead of `%<source>s`.'
+        MSG = 'Use `node.loc?` instead of `loc.respond_to?`.'
+        MSG_CORRECTABLE = 'Use `%<replacement>s` instead of `%<source>s`.'
+        RESTRICT_ON_SEND = %i[respond_to?].freeze
+
+        # @!method loc_respond_to?(node)
+        def_node_matcher :loc_respond_to?, <<~PATTERN
+          (call
+            (call $_receiver :loc) :respond_to?
+            $(sym _location))
+        PATTERN
 
         # @!method replaceable_with_loc_is(node)
         def_node_matcher :replaceable_with_loc_is, <<~PATTERN
@@ -64,6 +79,15 @@ module RuboCop
           replace_with_loc(node) || replace_with_loc_is(node)
         end
 
+        def on_send(node)
+          return if ignored_node?(node.parent)
+
+          loc_respond_to?(node) do |receiver, location|
+            register_offense(node, replacement(receiver, "loc?(#{location.source})"))
+          end
+        end
+        alias on_csend on_send
+
         private
 
         def replace_with_loc(node)
@@ -84,11 +108,13 @@ module RuboCop
         end
 
         def register_offense(node, replacement)
-          message = format(MSG, replacement: replacement, source: node.source)
+          message = format(MSG_CORRECTABLE, replacement: replacement, source: node.source)
 
           add_offense(node, message: message) do |corrector|
             corrector.replace(node, replacement)
           end
+
+          ignore_node(node)
         end
 
         def replacement(receiver, rest)

data/lib/rubocop/cop/internal_affairs/node_pattern_groups/ast_processor.rb

@@ -7,7 +7,7 @@ module RuboCop
         # AST Processor for NodePattern ASTs, for use with `InternalAffairs/NodePatternGroups`.
         #
         # Looks for sequences and subsequences where the first item is a `node_type` node,
-        # and converts them to `node_sequence` nodes (not a true `Rubocop::AST::NodePattern`
+        # and converts them to `node_sequence` nodes (not a true `RuboCop::AST::NodePattern`
         # node type).
         #
         # The resulting AST will be walked by `InternalAffairs::NodePatternGroups::ASTWalker`

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

@@ -145,8 +145,10 @@ module RuboCop
           next_sibling.if_type? && contains_guard_clause?(next_sibling)
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity
         def last_heredoc_argument(node)
           n = last_heredoc_argument_node(node)
+          n = n.children.first while n.respond_to?(:begin_type?) && n.begin_type?
 
           return n if heredoc?(n)
           return unless n.respond_to?(:arguments)
@@ -158,6 +160,7 @@ module RuboCop
 
           last_heredoc_argument(n.receiver) if n.respond_to?(:receiver)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity
 
         def last_heredoc_argument_node(node)
           return node unless node.respond_to?(:if_branch)

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

@@ -128,6 +128,10 @@ module RuboCop
           # assignment, we let rhs be the receiver of those method calls before
           # we check if it's an if/unless/while/until.
           return unless (rhs = first_part_of_call_chain(rhs))
+
+          # If `rhs` is a `begin` node, find the first non-`begin` child.
+          rhs = rhs.child_nodes.first while rhs.begin_type?
+
           return unless rhs.conditional?
           return if rhs.if_type? && rhs.ternary?
 

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

@@ -168,7 +168,7 @@ module RuboCop
 
         def subsequent_closing_parentheses_in_same_line?(outermost_send)
           last_arg_of_outer_send = outermost_send.last_argument
-          return false unless last_arg_of_outer_send&.loc.respond_to?(:end) &&
+          return false unless last_arg_of_outer_send&.loc?(:end) &&
                               (end_of_last_arg_of_outer_send = last_arg_of_outer_send.loc.end)
 
           end_of_outer_send = outermost_send.loc.end
@@ -230,7 +230,7 @@ module RuboCop
 
         def find_most_bottom_of_heredoc_end(arguments)
           arguments.filter_map do |argument|
-            argument.loc.heredoc_end.end_pos if argument.loc.respond_to?(:heredoc_end)
+            argument.loc.heredoc_end.end_pos if argument.loc?(:heredoc_end)
           end.max
         end
 

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

@@ -89,6 +89,7 @@ module RuboCop
         end
 
         def line_too_long?(node)
+          return false unless max_line_length
           return false if unlimited_heredoc_length?
 
           body = heredoc_body(node)
@@ -108,10 +109,6 @@ module RuboCop
           config.for_cop('Layout/LineLength')['AllowHeredoc']
         end
 
-        def max_line_length
-          config.for_cop('Layout/LineLength')['Max']
-        end
-
         def adjust_squiggly(corrector, node)
           corrector.replace(node.loc.heredoc_body, indented_body(node))
           corrector.replace(node.loc.heredoc_end, indented_end(node))

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

@@ -99,7 +99,7 @@ module RuboCop
 
             if str.heredoc?
               ranges << loc.heredoc_body
-            elsif loc.respond_to?(:begin) && loc.begin
+            elsif str.loc?(:begin)
               ranges << loc.expression
             end
           end

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

@@ -83,7 +83,10 @@ module RuboCop
 
           return unless begins_its_line?(end_loc)
 
-          check_indentation(end_loc, node.body)
+          # For blocks where the dot is on a new line, use the dot position as the base.
+          # Otherwise, use the end keyword position as the base.
+          base_loc = dot_on_new_line?(node) ? node.send_node.loc.dot : end_loc
+          check_indentation(base_loc, node.body)
 
           return unless indented_internal_methods_style?
 
@@ -383,6 +386,14 @@ module RuboCop
 
           leftmost_modifier_of(node.parent)
         end
+
+        def dot_on_new_line?(node)
+          send_node = node.send_node
+          return false unless send_node.loc?(:dot)
+
+          receiver = send_node.receiver
+          receiver && receiver.last_line < send_node.loc.dot.line
+        end
       end
     end
   end

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

@@ -101,7 +101,7 @@ module RuboCop
               ranges << loc.expression
             elsif literal.heredoc?
               ranges << loc.heredoc_body
-            elsif (loc.respond_to?(:begin) && loc.begin) || ignored_parent?(literal)
+            elsif literal.loc?(:begin) || ignored_parent?(literal)
               ranges << loc.expression
             end
           end

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

@@ -252,17 +252,22 @@ module RuboCop
           [max - indentation_difference(line), 0].max
         end
 
+        # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         def check_line(line, line_index)
           return if line_length(line) <= max
           return if allowed_line?(line, line_index)
+          if allow_rbs_inline_annotation? && rbs_inline_annotation_on_source_line?(line_index)
+            return
+          end
 
-          if ignore_cop_directives? && directive_on_source_line?(line_index)
+          if allow_cop_directives? && directive_on_source_line?(line_index)
             return check_directive_line(line, line_index)
           end
           return check_line_for_exemptions(line, line_index) if allow_uri? || allow_qualified_name?
 
           register_offense(excess_range(nil, line, line_index), line, line_index)
         end
+        # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
 
         def allowed_line?(line, line_index)
           matches_allowed_pattern?(line) ||
@@ -306,6 +311,7 @@ module RuboCop
         def max
           cop_config['Max']
         end
+        alias max_line_length max
 
         def allow_heredoc?
           allowed_heredoc
@@ -401,9 +407,7 @@ module RuboCop
 
         def string_delimiter(node)
           delimiter = node.loc.begin
-          if node.parent&.dstr_type? && node.parent.loc.respond_to?(:begin)
-            delimiter ||= node.parent.loc.begin
-          end
+          delimiter ||= node.parent.loc.begin if node.parent&.dstr_type? && node.parent.loc?(:begin)
           delimiter = delimiter&.source
 
           delimiter if %w[' "].include?(delimiter)

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

@@ -78,6 +78,8 @@ module RuboCop
         end
 
         def line_break_necessary_in_args?(node)
+          return false unless max_line_length
+
           needed_length_for_args(node) > max_line_length
         end
 

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

@@ -84,19 +84,23 @@ module RuboCop
           end
         end
 
+        # rubocop:disable Metrics/AbcSize
         def offending_range(node, lhs, rhs, given_style)
           return false unless begins_its_line?(rhs)
           return false if not_for_this_cop?(node)
 
           @base = alignment_base(node, rhs, given_style)
           correct_column = if @base
-                             @base.column + extra_indentation(given_style, node.parent)
+                             parent = node.parent
+                             parent = parent.parent if parent&.any_block_type?
+                             @base.column + extra_indentation(given_style, parent)
                            else
                              indentation(lhs) + correct_indentation(node)
                            end
           @column_delta = correct_column - rhs.column
           rhs if @column_delta.nonzero?
         end
+        # rubocop:enable Metrics/AbcSize
 
         def extra_indentation(given_style, parent)
           if given_style == :indented_relative_to_receiver