rubocop 1.32.0 → 1.35.1

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

@@ -14,8 +14,8 @@ module RuboCop
       #
       #
       # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
-      # for backwards compatibility. Please use `IgnoredMethods` instead.
-      # By default, there are no methods to ignored.
+      # for backwards compatibility. Please use `AllowedMethods` and `AllowedPatterns`
+      # instead. By default, there are no methods to allowed.
       #
       # @example CountAsOne: ['array', 'heredoc']
       #
@@ -38,14 +38,13 @@ module RuboCop
       # NOTE: This cop does not apply for `Struct` definitions.
       class BlockLength < Base
         include CodeLength
-        include IgnoredMethods
-
-        ignored_methods deprecated_key: 'ExcludedMethods'
+        include AllowedMethods
+        include AllowedPattern
 
         LABEL = 'Block'
 
         def on_block(node)
-          return if ignored_method?(node.method_name)
+          return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
           return if method_receiver_excluded?(node)
           return if node.class_constructor? || node.struct_constructor?
 
@@ -59,7 +58,7 @@ module RuboCop
           node_receiver = node.receiver&.source&.gsub(/\s+/, '')
           node_method = String(node.method_name)
 
-          ignored_methods.any? do |config|
+          allowed_methods.any? do |config|
             next unless config.is_a?(String)
 
             receiver, method = config.split('.')

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

@@ -4,16 +4,17 @@ module RuboCop
   module Cop
     module Metrics
       # Checks if the length of a method exceeds some maximum value.
-      # Comment lines can optionally be ignored.
+      # Comment lines can optionally be allowed.
       # The maximum allowed length is configurable.
       #
       # You can set literals you want to fold with `CountAsOne`.
       # Available are: 'array', 'hash', and 'heredoc'. Each literal
       # will be counted as one line regardless of its actual size.
       #
-      # NOTE: The `ExcludedMethods` configuration is deprecated and only kept
-      # for backwards compatibility. Please use `IgnoredMethods` instead.
-      # By default, there are no methods to ignored.
+      # NOTE: The `ExcludedMethods` and `IgnoredMethods` configuration is
+      # deprecated and only kept for backwards compatibility.
+      # Please use `AllowedMethods` and `AllowedPatterns` instead.
+      # By default, there are no methods to allowed.
       #
       # @example CountAsOne: ['array', 'heredoc']
       #
@@ -35,14 +36,13 @@ module RuboCop
       #
       class MethodLength < Base
         include CodeLength
-        include IgnoredMethods
-
-        ignored_methods deprecated_key: 'ExcludedMethods'
+        include AllowedMethods
+        include AllowedPattern
 
         LABEL = 'Method'
 
         def on_def(node)
-          return if ignored_method?(node.method_name)
+          return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
 
           check_code_length(node)
         end

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

@@ -12,10 +12,24 @@ module RuboCop
         allowed_methods.include?(name.to_s)
       end
 
+      # @deprecated Use allowed_method? instead
+      alias ignored_method? allowed_method?
+
       # @api public
       def allowed_methods
-        cop_config.fetch('AllowedMethods', [])
+        deprecated_values = cop_config_deprecated_values
+        if deprecated_values.any?(Regexp)
+          cop_config.fetch('AllowedMethods', [])
+        else
+          Array(cop_config['AllowedMethods']).concat(deprecated_values)
+        end
+      end
+
+      def cop_config_deprecated_values
+        Array(cop_config['IgnoredMethods']).concat(Array(cop_config['ExcludedMethods']))
       end
     end
+    # @deprecated IgnoredMethods class has been replaced with AllowedMethods.
+    IgnoredMethods = AllowedMethods
   end
 end

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

@@ -30,7 +30,15 @@ module RuboCop
       def allowed_patterns
         # Since there could be a pattern specified in the default config, merge the two
         # arrays together.
-        Array(cop_config['AllowedPatterns']).concat(Array(cop_config['IgnoredPatterns']))
+        patterns = Array(cop_config['AllowedPatterns']).concat(Array(cop_config['IgnoredPatterns']))
+        deprecated_values = cop_config_deprecated_methods_values
+        return patterns unless deprecated_values.any?(Regexp)
+
+        Array(patterns.concat(deprecated_values))
+      end
+
+      def cop_config_deprecated_methods_values
+        Array(cop_config['IgnoredMethods']).concat(Array(cop_config['ExcludedMethods']))
       end
     end
 

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

@@ -220,7 +220,7 @@ module RuboCop
       def already_on_multiple_lines?(node)
         return node.first_line != node.arguments.last.last_line if node.def_type?
 
-        node.first_line != node.last_line
+        !node.single_line?
       end
     end
   end

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

@@ -12,10 +12,14 @@ module RuboCop
       end
 
       def contains_comments?(node)
+        comments_in_range(node).any?
+      end
+
+      def comments_in_range(node)
         start_line = node.source_range.line
         end_line = find_end_line(node)
 
-        processed_source.each_comment_in_lines(start_line...end_line).any?
+        processed_source.each_comment_in_lines(start_line...end_line)
       end
 
       private

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

@@ -6,7 +6,8 @@ module RuboCop
     #
     # IMPORTANT: RuboCop core depended on this module when it supported Rails department.
     # Rails department has been extracted to RuboCop Rails gem.
-    # This module is deprecated and will be removed by RuboCop 2.0.
+    #
+    # @deprecated This module is deprecated and will be removed by RuboCop 2.0.
     # It will not be updated to `RuboCop::Cop::Base` v1 API to maintain compatibility
     # with existing RuboCop Rails 2.8 or lower.
     #

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

@@ -5,7 +5,22 @@ module RuboCop
     # This module checks for Ruby 3.1's hash value omission syntax.
     module HashShorthandSyntax
       OMIT_HASH_VALUE_MSG = 'Omit the hash value.'
-      EXPLICIT_HASH_VALUE_MSG = 'Explicit the hash value.'
+      EXPLICIT_HASH_VALUE_MSG = 'Include the hash value.'
+      DO_NOT_MIX_MSG_PREFIX = 'Do not mix explicit and implicit hash values.'
+      DO_NOT_MIX_OMIT_VALUE_MSG = "#{DO_NOT_MIX_MSG_PREFIX} #{OMIT_HASH_VALUE_MSG}"
+      DO_NOT_MIX_EXPLICIT_VALUE_MSG = "#{DO_NOT_MIX_MSG_PREFIX} #{EXPLICIT_HASH_VALUE_MSG}"
+
+      def on_hash_for_mixed_shorthand(hash_node)
+        return if ignore_mixed_hash_shorthand_syntax?(hash_node)
+
+        hash_value_type_breakdown = breakdown_value_types_of_hash(hash_node)
+
+        if hash_with_mixed_shorthand_syntax?(hash_value_type_breakdown)
+          mixed_shorthand_syntax_check(hash_value_type_breakdown)
+        else
+          no_mixed_shorthand_syntax_check(hash_value_type_breakdown)
+        end
+      end
 
       def on_pair(node)
         return if ignore_hash_shorthand_syntax?(node)
@@ -36,8 +51,14 @@ module RuboCop
         end
       end
 
+      def ignore_mixed_hash_shorthand_syntax?(hash_node)
+        target_ruby_version <= 3.0 || enforced_shorthand_syntax != 'consistent' ||
+          !hash_node.hash_type?
+      end
+
       def ignore_hash_shorthand_syntax?(pair_node)
         target_ruby_version <= 3.0 || enforced_shorthand_syntax == 'either' ||
+          enforced_shorthand_syntax == 'consistent' ||
           !pair_node.parent.hash_type?
       end
 
@@ -81,6 +102,60 @@ module RuboCop
 
         ancestor.respond_to?(:parenthesized?) && !ancestor.parenthesized? && !!right_sibling
       end
+
+      def breakdown_value_types_of_hash(hash_node)
+        hash_node.pairs.group_by do |pair_node|
+          if pair_node.value_omission?
+            :value_omitted
+          elsif require_hash_value?(pair_node.key.source, pair_node)
+            :value_needed
+          else
+            :value_omittable
+          end
+        end
+      end
+
+      def hash_with_mixed_shorthand_syntax?(hash_value_type_breakdown)
+        hash_value_type_breakdown.keys.size > 1
+      end
+
+      def hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown)
+        hash_value_type_breakdown[:value_needed]&.any?
+      end
+
+      def each_omitted_value_pair(hash_value_type_breakdown, &block)
+        hash_value_type_breakdown[:value_omitted]&.each(&block)
+      end
+
+      def each_omittable_value_pair(hash_value_type_breakdown, &block)
+        hash_value_type_breakdown[:value_omittable]&.each(&block)
+      end
+
+      def mixed_shorthand_syntax_check(hash_value_type_breakdown)
+        if hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown)
+          each_omitted_value_pair(hash_value_type_breakdown) do |pair_node|
+            hash_key_source = pair_node.key.source
+            replacement = "#{hash_key_source}: #{hash_key_source}"
+            register_offense(pair_node, DO_NOT_MIX_EXPLICIT_VALUE_MSG, replacement)
+          end
+        else
+          each_omittable_value_pair(hash_value_type_breakdown) do |pair_node|
+            hash_key_source = pair_node.key.source
+            replacement = "#{hash_key_source}:"
+            register_offense(pair_node, DO_NOT_MIX_OMIT_VALUE_MSG, replacement)
+          end
+        end
+      end
+
+      def no_mixed_shorthand_syntax_check(hash_value_type_breakdown)
+        return if hash_with_values_that_cant_be_omitted?(hash_value_type_breakdown)
+
+        each_omittable_value_pair(hash_value_type_breakdown) do |pair_node|
+          hash_key_source = pair_node.key.source
+          replacement = "#{hash_key_source}:"
+          register_offense(pair_node, OMIT_HASH_VALUE_MSG, replacement)
+        end
+      end
     end
   end
 end

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

@@ -14,7 +14,7 @@ module RuboCop
         {(array ...) (send _ :each_with_index) (send _ :with_index _ ?) (send _ :zip ...)}
       PATTERN
 
-      def on_block(node)
+      def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
         on_bad_each_with_object(node) do |*match|
           handle_possible_offense(node, match, 'each_with_object')
         end

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

@@ -6,21 +6,16 @@ module RuboCop
     #
     # This module handles measurement and reporting of complexity in methods.
     module MethodComplexity
-      include IgnoredMethods
+      include AllowedMethods
+      include AllowedPattern
       include Metrics::Utils::RepeatedCsendDiscount
       extend NodePattern::Macros
       extend ExcludeLimit
 
       exclude_limit 'Max'
 
-      # Ensure cops that include `MethodComplexity` have the config
-      # `attr_accessor`s that `ignored_method?` needs.
-      def self.included(base)
-        base.extend(IgnoredMethods::Config)
-      end
-
       def on_def(node)
-        return if ignored_method?(node.method_name)
+        return if allowed_method?(node.method_name) || matches_allowed_pattern?(node.method_name)
 
         check_complexity(node, node.method_name)
       end
@@ -28,20 +23,20 @@ module RuboCop
 
       def on_block(node)
         define_method?(node) do |name|
-          return if ignored_method?(name)
+          return if allowed_method?(name) || matches_allowed_pattern?(name)
 
           check_complexity(node, name)
         end
       end
 
+      alias on_numblock on_block
+
       private
 
       # @!method define_method?(node)
       def_node_matcher :define_method?, <<~PATTERN
-        (block
-         (send nil? :define_method ({sym str} $_))
-         args
-         _)
+        ({block numblock}
+         (send nil? :define_method ({sym str} $_)) _ _)
       PATTERN
 
       def check_complexity(node, method_name)

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

@@ -57,7 +57,7 @@ module RuboCop
         end
 
         if left_parenthesis && style == :special_inside_parentheses
-          return [left_parenthesis.column + 1, :first_colmn_after_left_parenthesis]
+          return [left_parenthesis.column + 1, :first_column_after_left_parenthesis]
         end
 
         [left_brace.source_line =~ /\S/, :start_of_line]

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

@@ -54,11 +54,11 @@ module RuboCop
       NOT_GIVEN = Module.new
       def range_with_surrounding_space(range_positional = NOT_GIVEN, # rubocop:disable Metrics/ParameterLists
                                        range: NOT_GIVEN, side: :both, newlines: true,
-                                       whitespace: false, continuations: false)
+                                       whitespace: false, continuations: false,
+                                       buffer: @processed_source.buffer)
 
         range = range_positional unless range_positional == NOT_GIVEN
 
-        buffer = @processed_source.buffer
         src = buffer.source
 
         go_left, go_right = directions(side)
@@ -70,9 +70,8 @@ module RuboCop
         Parser::Source::Range.new(buffer, begin_pos, end_pos)
       end
 
-      def range_by_whole_lines(range, include_final_newline: false)
-        buffer = @processed_source.buffer
-
+      def range_by_whole_lines(range, include_final_newline: false,
+                               buffer: @processed_source.buffer)
         last_line = buffer.source_line(range.last_line)
         end_offset = last_line.length - range.last_column
         end_offset += 1 if include_final_newline

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

@@ -38,7 +38,7 @@ module RuboCop
       class BlockParameterName < Base
         include UncommunicativeName
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           return unless node.arguments?
 
           check(node, node.arguments)

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

@@ -72,10 +72,10 @@ module RuboCop
         PATTERN
 
         def allowed_conditional_expression_on_rhs?(node)
-          node&.if_type? && contains_contant?(node)
+          node&.if_type? && contains_constant?(node)
         end
 
-        def contains_contant?(node)
+        def contains_constant?(node)
           node.branches.any?(&:const_type?)
         end
       end

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

@@ -3,9 +3,30 @@
 module RuboCop
   module Cop
     module Naming
-      # Makes sure that predicates are named properly.
-      # `is_a?` method is allowed by default.
-      # These are customizable with `AllowedMethods` option.
+      # Checks that predicate methods names end with a question mark and
+      # do not start with a forbidden prefix.
+      #
+      # A method is determined to be a predicate method if its name starts
+      # with one of the prefixes defined in the `NamePrefix` configuration.
+      # You can change what prefixes are considered by changing this option.
+      # Any method name that starts with one of these prefixes is required by
+      # the cop to end with a `?`. Other methods can be allowed by adding to
+      # the `AllowedMethods` configuration.
+      #
+      # NOTE: The `is_a?` method is allowed by default.
+      #
+      # If `ForbiddenPrefixes` is set, methods that start with the configured
+      # prefixes will not be allowed and will be removed by autocorrection.
+      #
+      # In other words, if `ForbiddenPrefixes` is empty, a method named `is_foo`
+      # will register an offense only due to the lack of question mark (and will be
+      # autocorrected to `is_foo?`). If `ForbiddenPrefixes` contains `is_`,
+      # `is_foo` will register an offense both because the ? is missing and because of
+      # the `is_` prefix, and will be corrected to `foo?`.
+      #
+      # NOTE: `ForbiddenPrefixes` is only applied to prefixes in `NamePrefix`;
+      # a prefix in the former but not the latter will not be considered by
+      # this cop.
       #
       # @example
       #   # bad

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

@@ -73,11 +73,11 @@ module RuboCop
           {
             (send _ _
               (splat (lvar %1))
-              (block-pass (lvar %2)))
+              (block-pass {(lvar %2) nil?}))
             (send _ _
               (splat (lvar %1))
               (hash (kwsplat (lvar %3)))
-              (block-pass (lvar %2)))
+              (block-pass {(lvar %2) nil?}))
           }
         PATTERN
 

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

@@ -10,7 +10,7 @@ module RuboCop
       # Methods that can be either procedural or functional and cannot be
       # categorised from their usage alone is ignored.
       # `lambda`, `proc`, and `it` are their defaults.
-      # Additional methods can be added to the `IgnoredMethods`.
+      # Additional methods can be added to the `AllowedMethods`.
       #
       # @example EnforcedStyle: line_count_based (default)
       #   # bad - single line block
@@ -66,7 +66,7 @@ module RuboCop
       #     x
       #   }.inspect
       #
-      #   # The AllowBracesOnProceduralOneLiners option is ignored unless the
+      #   # The AllowBracesOnProceduralOneLiners option is allowed unless the
       #   # EnforcedStyle is set to `semantic`. If so:
       #
       #   # If the AllowBracesOnProceduralOneLiners option is unspecified, or
@@ -116,7 +116,7 @@ module RuboCop
       #
       #   # Methods listed in the BracesRequiredMethods list, such as 'sig'
       #   # in this example, will require `{...}` braces. This option takes
-      #   # precedence over all other configurations except IgnoredMethods.
+      #   # precedence over all other configurations except AllowedMethods.
       #
       #   # bad
       #   sig do
@@ -138,7 +138,7 @@ module RuboCop
       #     puts foo
       #   end
       #
-      # @example IgnoredMethods: ['lambda', 'proc', 'it' ] (default)
+      # @example AllowedMethods: ['lambda', 'proc', 'it' ] (default)
       #
       #   # good
       #   foo = lambda do |x|
@@ -149,9 +149,26 @@ module RuboCop
       #     x * 100
       #   end
       #
+      # @example AllowedPatterns: [] (default)
+      #
+      #   # bad
+      #   things.map { |thing|
+      #     something = thing.some_method
+      #     process(something)
+      #   }
+      #
+      # @example AllowedPatterns: [/map/]
+      #
+      #   # good
+      #   things.map { |thing|
+      #     something = thing.some_method
+      #     process(something)
+      #   }
+      #
       class BlockDelimiters < Base
         include ConfigurableEnforcedStyle
-        include IgnoredMethods
+        include AllowedMethods
+        include AllowedPattern
         include RangeHelp
         extend AutoCorrector
 
@@ -330,12 +347,14 @@ module RuboCop
         end
 
         def special_method?(method_name)
-          ignored_method?(method_name) || braces_required_method?(method_name)
+          allowed_method?(method_name) ||
+            matches_allowed_pattern?(method_name) ||
+            braces_required_method?(method_name)
         end
 
         def special_method_proper_block_style?(node)
           method_name = node.method_name
-          return true if ignored_method?(method_name)
+          return true if allowed_method?(method_name) || matches_allowed_pattern?(method_name)
           return node.braces? if braces_required_method?(method_name)
         end
 

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

@@ -117,10 +117,10 @@ module RuboCop
         end
 
         def remove_end(corrector, body)
-          range = range_between(
-            body.loc.end.begin_pos - leading_spaces(body).size,
-            body.loc.end.end_pos + 1
-          )
+          remove_begin_pos = body.loc.end.begin_pos - leading_spaces(body).size
+          adjustment = processed_source.raw_source[remove_begin_pos] == ';' ? 0 : 1
+          range = range_between(remove_begin_pos, body.loc.end.end_pos + adjustment)
+
           corrector.remove(range)
         end
 

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

@@ -5,8 +5,8 @@ module RuboCop
     module Style
       # Enforces the use of `Object#instance_of?` instead of class comparison
       # for equality.
-      # `==`, `equal?`, and `eql?` methods are ignored by default.
-      # These are customizable with `IgnoredMethods` option.
+      # `==`, `equal?`, and `eql?` methods are allowed by default.
+      # These are customizable with `AllowedMethods` option.
       #
       # @example
       #   # bad
@@ -18,7 +18,7 @@ module RuboCop
       #   # good
       #   var.instance_of?(Date)
       #
-      # @example IgnoreMethods: [] (default)
+      # @example AllowedMethods: [] (default)
       #   # good
       #   var.instance_of?(Date)
       #
@@ -28,7 +28,7 @@ module RuboCop
       #   var.class.eql?(Date)
       #   var.class.name == 'Date'
       #
-      # @example IgnoreMethods: [`==`]
+      # @example AllowedMethods: [`==`]
       #   # good
       #   var.instance_of?(Date)
       #   var.class == Date
@@ -38,9 +38,30 @@ module RuboCop
       #   var.class.equal?(Date)
       #   var.class.eql?(Date)
       #
+      # @example AllowedPatterns: [] (default)
+      #   # good
+      #   var.instance_of?(Date)
+      #
+      #   # bad
+      #   var.class == Date
+      #   var.class.equal?(Date)
+      #   var.class.eql?(Date)
+      #   var.class.name == 'Date'
+      #
+      # @example AllowedPatterns: [`/eq/`]
+      #   # good
+      #   var.instance_of?(Date)
+      #   var.class.equal?(Date)
+      #   var.class.eql?(Date)
+      #
+      #   # bad
+      #   var.class == Date
+      #   var.class.name == 'Date'
+      #
       class ClassEqualityComparison < Base
         include RangeHelp
-        include IgnoredMethods
+        include AllowedMethods
+        include AllowedPattern
         extend AutoCorrector
 
         MSG = 'Use `instance_of?(%<class_name>s)` instead of comparing classes.'
@@ -56,7 +77,9 @@ module RuboCop
 
         def on_send(node)
           def_node = node.each_ancestor(:def, :defs).first
-          return if def_node && ignored_method?(def_node.method_name)
+          return if def_node &&
+                    (allowed_method?(def_node.method_name) ||
+                    matches_allowed_pattern?(def_node.method_name))
 
           class_comparison_candidate?(node) do |receiver_node, class_node|
             range = offense_range(receiver_node, node)
@@ -74,7 +97,9 @@ module RuboCop
           if node.children.first.method?(:name)
             return class_node.receiver.source if class_node.receiver
 
-            class_node.source.delete('"').delete("'")
+            value = class_node.source.delete('"').delete("'")
+            value.prepend('::') if class_node.each_ancestor(:class, :module).any?
+            value
           else
             class_node.source
           end

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

@@ -70,7 +70,7 @@ module RuboCop
 
         def on_sclass(node)
           return unless def_self_style?
-          return unless node.identifier.source == 'self'
+          return unless node.identifier.self_type?
           return unless all_methods_public?(node)
 
           add_offense(node, message: MSG_SCLASS) do |corrector|
@@ -80,6 +80,7 @@ module RuboCop
 
         def on_defs(node)
           return if def_self_style?
+          return unless node.receiver.self_type?
 
           message = format(MSG, preferred: 'class << self')
           add_offense(node, message: message)

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

@@ -48,6 +48,8 @@ module RuboCop
           check_method_node(node.send_node)
         end
 
+        alias on_numblock on_block
+
         def on_send(node)
           return unless implicit_block?(node)
 

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

@@ -66,6 +66,8 @@ module RuboCop
           add_offense(node) if same_collection_looping?(node, node.left_sibling)
         end
 
+        alias on_numblock on_block
+
         def on_for(node)
           return unless node.parent&.begin_type?
 
@@ -82,7 +84,7 @@ module RuboCop
         end
 
         def same_collection_looping?(node, sibling)
-          sibling&.block_type? &&
+          (sibling&.block_type? || sibling&.numblock_type?) &&
             sibling.send_node.method?(node.method_name) &&
             sibling.receiver == node.receiver &&
             sibling.send_node.arguments == node.send_node.arguments

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

@@ -93,6 +93,8 @@ module RuboCop
 
           if conditional_node
             double_negative_condition_return_value?(node, last_child, conditional_node)
+          elsif last_child.pair_type? || last_child.hash_type? || last_child.parent.array_type?
+            false
           else
             last_child.last_line <= node.last_line
           end