rubocop 1.45.1 → 1.47.0

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

@@ -71,7 +71,7 @@ module RuboCop
         end
 
         def with_object_range(send)
-          range_between(send.loc.selector.begin_pos, send.loc.expression.end_pos)
+          range_between(send.loc.selector.begin_pos, send.source_range.end_pos)
         end
       end
     end

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

@@ -41,7 +41,8 @@ module RuboCop
 
         def on_send(node)
           return if node.receiver
-          return unless node.parent.block_type? && node.parent.method?(:refine)
+          return unless (parent = node.parent)
+          return unless parent.block_type? && parent.method?(:refine)
 
           add_offense(node.loc.selector, message: format(MSG, current: node.method_name))
         end

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

@@ -50,7 +50,7 @@ module RuboCop
           return if invalid_exceptions.empty?
 
           add_offense(
-            node.loc.keyword.join(rescued.loc.expression),
+            node.loc.keyword.join(rescued.source_range),
             message: format(MSG, invalid_exceptions: invalid_exceptions.map(&:source).join(', '))
           ) do |corrector|
             autocorrect(corrector, node)
@@ -59,9 +59,9 @@ module RuboCop
 
         def autocorrect(corrector, node)
           rescued, _, _body = *node
-          range = Parser::Source::Range.new(node.loc.expression.source_buffer,
+          range = Parser::Source::Range.new(node.source_range.source_buffer,
                                             node.loc.keyword.end_pos,
-                                            rescued.loc.expression.end_pos)
+                                            rescued.source_range.end_pos)
 
           corrector.replace(range, correction(*rescued))
         end

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

@@ -65,7 +65,7 @@ module RuboCop
         end
 
         def location(node, unsafe_method_call)
-          node.loc.expression.join(unsafe_method_call.loc.expression)
+          node.source_range.join(unsafe_method_call.source_range)
         end
 
         def top_conditional_ancestor(node)

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

@@ -53,7 +53,7 @@ module RuboCop
         private
 
         def autocorrect(comment)
-          FileUtils.chmod('+x', comment.loc.expression.source_buffer.name)
+          FileUtils.chmod('+x', comment.source_range.source_buffer.name)
         end
 
         def executable?(processed_source)

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

@@ -83,7 +83,7 @@ module RuboCop
 
         def offense_range(rescues)
           shadowing_rescue = find_shadowing_rescue(rescues)
-          expression = shadowing_rescue.loc.expression
+          expression = shadowing_rescue.source_range
           range_between(expression.begin_pos, expression.end_pos)
         end
 

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

@@ -43,8 +43,12 @@ module RuboCop
           return unless def_node
 
           enum_conversion_call?(node) do |method_node, arguments|
-            add_offense(node) unless method_name?(method_node, def_node.method_name) &&
-                                     arguments_match?(arguments, def_node)
+            next if method_node.call_type? &&
+                    !method_node.method?(:__method__) && !method_node.method?(:__callee__)
+            next if method_name?(method_node, def_node.method_name) &&
+                    arguments_match?(arguments, def_node)
+
+            add_offense(node)
           end
         end
 

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

@@ -167,14 +167,6 @@ module RuboCop
           ({block numblock} (send _ {:class_eval :instance_eval}) ...)
         PATTERN
 
-        # @!method class_constructor?(node)
-        def_node_matcher :class_constructor?, <<~PATTERN
-          ({block numblock} {
-            (send (const {nil? cbase} {:Class :Module :Struct}) :new ...)
-            (send (const {nil? cbase} :Data) :define ...)
-          } ...)
-        PATTERN
-
         def check_node(node)
           return if node.nil?
 
@@ -273,7 +265,7 @@ module RuboCop
 
         def eval_call?(child)
           class_or_instance_eval?(child) ||
-            class_constructor?(child) ||
+            child.class_constructor? ||
             any_context_creating_methods?(child)
         end
 

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

@@ -72,8 +72,9 @@ module RuboCop
         def use_exception_variable_in_ensure?(resbody_node)
           return false unless (exception_variable = resbody_node.exception_variable)
           return false unless (ensure_node = resbody_node.each_ancestor(:ensure).first)
+          return false unless (ensure_body = ensure_node.body)
 
-          ensure_node.body.each_descendant(:lvar).map(&:source).include?(exception_variable.source)
+          ensure_body.each_descendant(:lvar).map(&:source).include?(exception_variable.source)
         end
 
         def exception_objects(resbody_node)

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

@@ -74,7 +74,7 @@ module RuboCop
         end
 
         def remove_node(corrector, node)
-          corrector.remove(range_by_whole_lines(node.loc.expression, include_final_newline: true))
+          corrector.remove(range_by_whole_lines(node.source_range, include_final_newline: true))
         end
 
         def autocorrect_block_pass(corrector, node, proc_name)

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

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Metrics
+      # Checks for literals with extremely many entries. This is indicative of
+      # configuration or data that may be better extracted somewhere else, like
+      # a database, fetched from an API, or read from a non-code file (CSV,
+      # JSON, YAML, etc.).
+      #
+      # @example
+      #   # bad
+      #   # Huge Array literal
+      #   [1, 2, '...', 999_999_999]
+      #
+      #   # bad
+      #   # Huge Hash literal
+      #   { 1 => 1, 2 => 2, '...' => '...', 999_999_999 => 999_999_999}
+      #
+      #   # bad
+      #   # Huge Set "literal"
+      #   Set[1, 2, '...', 999_999_999]
+      #
+      #   # good
+      #   # Reasonably sized Array literal
+      #   [1, 2, '...', 10]
+      #
+      #   # good
+      #   # Reading huge Array from external data source
+      #   # File.readlines('numbers.txt', chomp: true).map!(&:to_i)
+      #
+      #   # good
+      #   # Reasonably sized Hash literal
+      #   { 1 => 1, 2 => 2, '...' => '...', 10 => 10}
+      #
+      #   # good
+      #   # Reading huge Hash from external data source
+      #   CSV.foreach('numbers.csv', headers: true).each_with_object({}) do |row, hash|
+      #     hash[row["key"].to_i] = row["value"].to_i
+      #   end
+      #
+      #   # good
+      #   # Reasonably sized Set "literal"
+      #   Set[1, 2, '...', 10]
+      #
+      #   # good
+      #   # Reading huge Set from external data source
+      #   SomeFramework.config_for(:something)[:numbers].to_set
+      #
+      class CollectionLiteralLength < Base
+        MSG = 'Avoid hard coding large quantities of data in code. ' \
+              'Prefer reading the data from an external source.'
+        RESTRICT_ON_SEND = [:[]].freeze
+
+        def on_array(node)
+          add_offense(node) if node.children.length >= collection_threshold
+        end
+        alias on_hash on_array
+
+        def on_index(node)
+          add_offense(node) if node.arguments.length >= collection_threshold
+        end
+
+        def on_send(node)
+          on_index(node) if node.method?(:[])
+        end
+
+        private
+
+        def collection_threshold
+          cop_config.fetch('LengthThreshold', Float::INFINITY)
+        end
+      end
+    end
+  end
+end

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

@@ -163,8 +163,8 @@ module RuboCop
             return 0 unless parenthesized?(parent)
 
             [
-              parent.loc.begin.end_pos != descendant.loc.expression.begin_pos,
-              parent.loc.end.begin_pos != descendant.loc.expression.end_pos
+              parent.loc.begin.end_pos != descendant.source_range.begin_pos,
+              parent.loc.end.begin_pos != descendant.source_range.end_pos
             ].count(true)
           end
 

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

@@ -45,7 +45,7 @@ module RuboCop
         end
 
         def check_cop_name(name, comment, offset)
-          start = comment.location.expression.begin_pos + offset
+          start = comment.source_range.begin_pos + offset
           range = range_between(start, start + name.length)
 
           add_offense(range) do |corrector|

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

@@ -29,7 +29,7 @@ module RuboCop
 
       # Returns the range bounds for just the annotation
       def bounds
-        start = comment.loc.expression.begin_pos + margin.length
+        start = comment.source_range.begin_pos + margin.length
         length = [keyword, colon, space].reduce(0) { |len, elem| len + elem.to_s.length }
         [start, start + length]
       end

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

@@ -36,7 +36,7 @@ module RuboCop
         length = calculator.calculate
         return if length <= max_length
 
-        location = node.casgn_type? ? node.loc.name : node.loc.expression
+        location = node.casgn_type? ? node.loc.name : node.source_range
 
         add_offense(location, message: message(length, max_length)) { self.max = length }
       end

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

@@ -37,7 +37,7 @@ module RuboCop
       private
 
       def end_position_for(node)
-        end_line = buffer.line_for_position(node.loc.expression.end_pos)
+        end_line = buffer.line_for_position(node.source_range.end_pos)
         buffer.line_range(end_line).end_pos
       end
 
@@ -68,7 +68,7 @@ module RuboCop
           node.loc.else.line
         elsif node.if_type? && node.ternary?
           node.else_branch.loc.line
-        elsif (next_sibling = node.right_sibling)
+        elsif (next_sibling = node.right_sibling) && next_sibling.is_a?(AST::Node)
           next_sibling.loc.line
         elsif (parent = node.parent)
           parent.loc.end ? parent.loc.end.line : parent.loc.line

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

@@ -23,7 +23,7 @@ module RuboCop
       # The args node1 & node2 may represent a RuboCop::AST::Node
       # or a Parser::Source::Comment. Both respond to #loc.
       def preceding_comment?(node1, node2)
-        node1 && node2 && precede?(node2, node1) && comment_line?(node2.loc.expression.source)
+        node1 && node2 && precede?(node2, node1) && comment_line?(node2.source)
       end
 
       # The args node1 & node2 may represent a RuboCop::AST::Node

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

@@ -33,7 +33,7 @@ module RuboCop
 
         def separator_delta(pair)
           if pair.hash_rocket?
-            correct_separator_column = pair.key.loc.expression.end.column + 1
+            correct_separator_column = pair.key.source_range.end.column + 1
             actual_separator_column = pair.loc.operator.column
 
             correct_separator_column - actual_separator_column

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

@@ -95,19 +95,19 @@ module RuboCop
           use_modifier_form_without_parenthesized_method_call?(method_dispatch_node)
       end
 
-      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity
       def def_node_that_require_parentheses(node)
         last_pair = node.parent.pairs.last
         return unless last_pair.key.source == last_pair.value.source
         return unless (dispatch_node = find_ancestor_method_dispatch_node(node))
-        return if node.respond_to?(:parenthesized?) && !node.parenthesized?
-        return unless last_expression?(dispatch_node) || method_dispatch_as_argument?(dispatch_node)
+        return if dispatch_node.parenthesized?
+        return if last_expression?(dispatch_node) && !method_dispatch_as_argument?(dispatch_node)
 
         def_node = node.each_ancestor(:send, :csend, :super, :yield).first
 
         DefNode.new(def_node) unless def_node && def_node.arguments.empty?
       end
-      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity
 
       def find_ancestor_method_dispatch_node(node)
         return unless (ancestor = node.parent.parent)
@@ -132,9 +132,12 @@ module RuboCop
         ancestor.ancestors.any? { |node| node.respond_to?(:modifier_form?) && node.modifier_form? }
       end
 
-      def last_expression?(ancestor)
-        ancestor.right_sibling ||
-          ancestor.each_ancestor.find { |node| node.assignment? || node.send_type? }&.right_sibling
+      def last_expression?(node)
+        return false if node.right_sibling
+        return true unless (assignment_node = node.each_ancestor.find(&:assignment?))
+        return last_expression?(assignment_node.parent) if assignment_node.parent&.assignment?
+
+        !assignment_node.right_sibling
       end
 
       def method_dispatch_as_argument?(method_dispatch_node)

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

@@ -159,7 +159,7 @@ module RuboCop
         end
 
         def strip_prefix_and_suffix(node, corrector)
-          expression = node.loc.expression
+          expression = node.source_range
           corrector.remove_leading(expression, leading)
           corrector.remove_trailing(expression, trailing)
         end
@@ -175,11 +175,11 @@ module RuboCop
         end
 
         def set_new_arg_name(transformed_argname, corrector)
-          corrector.replace(block_node.arguments.loc.expression, "|#{transformed_argname}|")
+          corrector.replace(block_node.arguments.source_range, "|#{transformed_argname}|")
         end
 
         def set_new_body_expression(transforming_body_expr, corrector)
-          body_source = transforming_body_expr.loc.expression.source
+          body_source = transforming_body_expr.source
           if transforming_body_expr.hash_type? && !transforming_body_expr.braces?
             body_source = "{ #{body_source} }"
           end

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

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-# TEAM: backend_infra
-# WATCHERS: maxh
-
 module RuboCop
   module Cop
     # Common functionality for checking for a line break before each

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

@@ -10,7 +10,7 @@ module RuboCop
       def get_source_range(node, comments_as_separators)
         unless comments_as_separators
           first_comment = processed_source.ast_with_comments[node].first
-          return first_comment.loc.expression unless first_comment.nil?
+          return first_comment.source_range unless first_comment.nil?
         end
         node.source_range
       end

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

@@ -132,12 +132,7 @@ module RuboCop
       end
 
       def range_with_comments(node)
-        ranges = [
-          node,
-          *@processed_source.ast_with_comments[node]
-        ].map do |element|
-          element.location.expression
-        end
+        ranges = [node, *@processed_source.ast_with_comments[node]].map(&:source_range)
         ranges.reduce do |result, range|
           add_range(result, range)
         end

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

@@ -65,14 +65,14 @@ module RuboCop
       end
 
       def method_source(if_body)
-        range_between(if_body.loc.expression.begin_pos, if_body.loc.selector.end_pos).source
+        range_between(if_body.source_range.begin_pos, if_body.loc.selector.end_pos).source
       end
 
       def first_line_comment(node)
         comment = processed_source.find_comment { |c| same_line?(c, node) }
         return unless comment
 
-        comment_source = comment.loc.expression.source
+        comment_source = comment.source
         comment_source unless comment_disables_cop?(comment_source)
       end
 

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

@@ -75,7 +75,7 @@ module RuboCop
 
       def inside_comment?(range, comma_offset)
         comment = processed_source.comment_at_line(range.line)
-        comment && comment.loc.expression.begin_pos < range.begin_pos + comma_offset
+        comment && comment.source_range.begin_pos < range.begin_pos + comma_offset
       end
 
       # Returns true if the node has round/square/curly brackets.

data/lib/rubocop/cop/naming/heredoc_delimiter_case.rb

@@ -38,7 +38,7 @@ module RuboCop
           return if correct_case_delimiters?(node)
 
           add_offense(node.loc.heredoc_end) do |corrector|
-            expr = node.loc.expression
+            expr = node.source_range
 
             corrector.replace(expr, correct_delimiters(expr.source))
             corrector.replace(node.loc.heredoc_end, correct_delimiters(delimiter_string(expr)))

data/lib/rubocop/cop/naming/method_name.rb

@@ -67,7 +67,7 @@ module RuboCop
 
         def range_position(node)
           selector_end_pos = node.loc.selector.end_pos + 1
-          expr_end_pos = node.loc.expression.end_pos
+          expr_end_pos = node.source_range.end_pos
 
           range_between(selector_end_pos, expr_end_pos)
         end

data/lib/rubocop/cop/naming/predicate_name.rb

@@ -72,7 +72,7 @@ module RuboCop
               next if allowed_method_name?(method_name.to_s, prefix)
 
               add_offense(
-                node.first_argument.loc.expression,
+                node.first_argument.source_range,
                 message: message(method_name, expected_name(method_name.to_s, prefix))
               )
             end

data/lib/rubocop/cop/naming/rescued_exceptions_variable_name.rb

@@ -92,7 +92,7 @@ module RuboCop
 
         def offense_range(resbody)
           variable = resbody.exception_variable
-          variable.loc.expression
+          variable.source_range
         end
 
         def variable_name_matches?(node, name)

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

@@ -7,8 +7,8 @@ module RuboCop
       # By default it enforces accessors to be placed in grouped declarations,
       # but it can be configured to enforce separating them in multiple declarations.
       #
-      # NOTE: `Sorbet` is not compatible with "grouped" style. Consider "separated" style
-      # or disabling this cop.
+      # NOTE: If there is a method call before the accessor method it is always allowed
+      # as it might be intended like Sorbet.
       #
       # @example EnforcedStyle: grouped (default)
       #   # bad
@@ -22,6 +22,15 @@ module RuboCop
       #     attr_reader :bar, :baz
       #   end
       #
+      #   # good
+      #   class Foo
+      #     # may be intended comment for bar.
+      #     attr_reader :bar
+      #
+      #     may_be_intended_annotation :baz
+      #     attr_reader :baz
+      #   end
+      #
       # @example EnforcedStyle: separated
       #   # bad
       #   class Foo
@@ -43,11 +52,9 @@ module RuboCop
         GROUPED_MSG = 'Group together all `%<accessor>s` attributes.'
         SEPARATED_MSG = 'Use one attribute per `%<accessor>s`.'
 
-        ACCESSOR_METHODS = %i[attr_reader attr_writer attr_accessor attr].freeze
-
         def on_class(node)
           class_send_elements(node).each do |macro|
-            next unless accessor?(macro)
+            next unless macro.attribute_accessor?
 
             check(macro)
           end
@@ -58,7 +65,7 @@ module RuboCop
         private
 
         def check(send_node)
-          return if previous_line_comment?(send_node)
+          return if previous_line_comment?(send_node) || !groupable_accessor?(send_node)
           return unless (grouped_style? && sibling_accessors(send_node).size > 1) ||
                         (separated_style? && send_node.arguments.size > 1)
 
@@ -72,7 +79,7 @@ module RuboCop
           if (preferred_accessors = preferred_accessors(node))
             corrector.replace(node, preferred_accessors)
           else
-            range = range_with_surrounding_space(node.loc.expression, side: :left)
+            range = range_with_surrounding_space(node.source_range, side: :left)
             corrector.remove(range)
           end
         end
@@ -81,6 +88,13 @@ module RuboCop
           comment_line?(processed_source[node.first_line - 2])
         end
 
+        def groupable_accessor?(node)
+          return true unless (previous_expression = node.left_siblings.last)
+          return true unless previous_expression.send_type?
+
+          previous_expression.attribute_accessor? || previous_expression.access_modifier?
+        end
+
         def class_send_elements(class_node)
           class_def = class_node.body
 
@@ -93,10 +107,6 @@ module RuboCop
           end
         end
 
-        def accessor?(send_node)
-          send_node.macro? && ACCESSOR_METHODS.include?(send_node.method_name)
-        end
-
         def grouped_style?
           style == :grouped
         end
@@ -107,7 +117,7 @@ module RuboCop
 
         def sibling_accessors(send_node)
           send_node.parent.each_child_node(:send).select do |sibling|
-            accessor?(sibling) &&
+            sibling.attribute_accessor? &&
               sibling.method?(send_node.method_name) &&
               node_visibility(sibling) == node_visibility(send_node) &&
               !previous_line_comment?(sibling)

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

@@ -124,9 +124,9 @@ module RuboCop
 
         def register_offense_to_forwarding_method_arguments(forwarding_method)
           add_offense(arguments_range(forwarding_method)) do |corrector|
-            range = range_between(
-              forwarding_method.loc.selector.end_pos, forwarding_method.source_range.end_pos
-            )
+            begin_pos = forwarding_method.loc.selector&.end_pos || forwarding_method.loc.dot.end_pos
+            range = range_between(begin_pos, forwarding_method.source_range.end_pos)
+
             corrector.replace(range, '(...)')
           end
         end

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

@@ -12,7 +12,7 @@ module RuboCop
       # `(array1 & array2).any?` and is more readable.
       #
       # @safety
-      #   This cop cannot guarantee that array1 and array2 are
+      #   This cop cannot guarantee that `array1` and `array2` are
       #   actually arrays while method `intersect?` is for arrays only.
       #
       # @example

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

@@ -30,7 +30,7 @@ module RuboCop
         private
 
         def first_offense_range(comment)
-          expression    = comment.loc.expression
+          expression    = comment.source_range
           first_offense = first_non_ascii_chars(comment.text)
 
           start_position = expression.begin_pos + comment.text.index(first_offense)

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

@@ -55,7 +55,7 @@ module RuboCop
         def after_class(class_node)
           @macros_to_rewrite[class_node].each do |macro|
             node = macro.node
-            range = range_by_whole_lines(node.loc.expression, include_final_newline: true)
+            range = range_by_whole_lines(node.source_range, include_final_newline: true)
 
             correct(range) do |corrector|
               if macro.writer?

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

@@ -46,7 +46,7 @@ module RuboCop
         private
 
         def parts(comment)
-          expr = comment.loc.expression
+          expr = comment.source_range
           eq_begin = expr.resize(BEGIN_LENGTH)
           eq_end = eq_end_part(comment, expr)
           contents = range_between(eq_begin.end_pos, eq_end.begin_pos)

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

@@ -299,7 +299,7 @@ module RuboCop
 
         def move_comment_before_block(corrector, comment, block_node, closing_brace)
           range = block_node.chained? ? end_of_chain(block_node.parent).source_range : closing_brace
-          corrector.remove(range_with_surrounding_space(comment.loc.expression, side: :right))
+          corrector.remove(range_with_surrounding_space(comment.source_range, side: :right))
           remove_trailing_whitespace(corrector, range, comment)
           corrector.insert_after(range, "\n")
 
@@ -314,7 +314,7 @@ module RuboCop
         end
 
         def remove_trailing_whitespace(corrector, range, comment)
-          range_of_trailing = range.end.join(comment.loc.expression.begin)
+          range_of_trailing = range.end.join(comment.source_range.begin)
 
           corrector.remove(range_of_trailing) if range_of_trailing.source.match?(/\A\s+\z/)
         end

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

@@ -239,7 +239,7 @@ module RuboCop
         end
 
         def correction_range(node)
-          range_between(node.parent.loc.keyword.begin_pos, node.loc.expression.end_pos)
+          range_between(node.parent.loc.keyword.begin_pos, node.source_range.end_pos)
         end
 
         # Named captures work with `=~` (if regexp is on lhs) and with `match` (both sides)

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

@@ -112,7 +112,7 @@ module RuboCop
         end
 
         def range(begin_pos_node, end_pos_node)
-          range_between(begin_pos_node.loc.selector.begin_pos, end_pos_node.loc.expression.end_pos)
+          range_between(begin_pos_node.loc.selector.begin_pos, end_pos_node.source_range.end_pos)
         end
       end
     end