rubocop-rails 2.15.2 → 2.16.1

data/lib/rubocop/cop/rails/deprecated_active_model_errors_methods.rb

@@ -37,7 +37,8 @@ module RuboCop
         extend AutoCorrector
 
         MSG = 'Avoid manipulating ActiveModel errors as hash directly.'
-        AUTOCORECTABLE_METHODS = %i[<< clear keys].freeze
+        AUTOCORRECTABLE_METHODS = %i[<< clear keys].freeze
+        INCOMPATIBLE_METHODS = %i[keys values to_h to_xml].freeze
 
         MANIPULATIVE_METHODS = Set[
           *%i[
@@ -55,7 +56,7 @@ module RuboCop
           {
             #root_manipulation?
             #root_assignment?
-            #errors_keys?
+            #errors_deprecated?
             #messages_details_manipulation?
             #messages_details_assignment?
           }
@@ -77,10 +78,10 @@ module RuboCop
             ...)
         PATTERN
 
-        def_node_matcher :errors_keys?, <<~PATTERN
+        def_node_matcher :errors_deprecated?, <<~PATTERN
           (send
             (send #receiver_matcher :errors)
-            :keys)
+            {:keys :values :to_h :to_xml})
         PATTERN
 
         def_node_matcher :messages_details_manipulation?, <<~PATTERN
@@ -106,10 +107,10 @@ module RuboCop
 
         def on_send(node)
           any_manipulation?(node) do
-            next if node.method?(:keys) && target_rails_version <= 6.0
+            next if target_rails_version <= 6.0 && INCOMPATIBLE_METHODS.include?(node.method_name)
 
             add_offense(node) do |corrector|
-              next unless AUTOCORECTABLE_METHODS.include?(node.method_name)
+              next if skip_autocorrect?(node)
 
               autocorrect(corrector, node)
             end
@@ -118,14 +119,16 @@ module RuboCop
 
         private
 
+        def skip_autocorrect?(node)
+          return true unless AUTOCORRECTABLE_METHODS.include?(node.method_name)
+          return false unless (receiver = node.receiver.receiver)
+
+          receiver.send_type? && receiver.method?(:details) && node.method?(:<<)
+        end
+
         def autocorrect(corrector, node)
           receiver = node.receiver
 
-          if receiver.receiver.send_type? && receiver.receiver.method?(:messages)
-            corrector.remove(receiver.receiver.loc.dot)
-            corrector.remove(receiver.receiver.loc.selector)
-          end
-
           range = offense_range(node, receiver)
           replacement = replacement(node, receiver)
 
@@ -133,11 +136,12 @@ module RuboCop
         end
 
         def offense_range(node, receiver)
-          range_between(receiver.receiver.source_range.end_pos, node.source_range.end_pos)
+          receiver = receiver.receiver while receiver.send_type? && !receiver.method?(:errors) && receiver.receiver
+          range_between(receiver.source_range.end_pos, node.source_range.end_pos)
         end
 
         def replacement(node, receiver)
-          return '.errors.attribute_names' if node.method?(:keys)
+          return '.attribute_names' if node.method?(:keys)
 
           key = receiver.first_argument.source
 

data/lib/rubocop/cop/rails/dot_separated_keys.rb

@@ -37,7 +37,7 @@ module RuboCop
 
             add_offense(scope_node) do |corrector|
               # Eat the comma on the left.
-              range = range_with_surrounding_space(range: scope_node.source_range, side: :left)
+              range = range_with_surrounding_space(scope_node.source_range, side: :left)
               range = range_with_surrounding_comma(range, :left)
               corrector.remove(range)
 

data/lib/rubocop/cop/rails/dynamic_find_by.rb

@@ -70,8 +70,7 @@ module RuboCop
         end
 
         def allowed_invocation?(node)
-          allowed_method?(node) || allowed_receiver?(node) ||
-            whitelisted?(node)
+          allowed_method?(node) || allowed_receiver?(node) || whitelisted?(node)
         end
 
         def allowed_method?(node)
@@ -95,8 +94,7 @@ module RuboCop
         end
 
         def autocorrect_method_name(corrector, node)
-          corrector.replace(node.loc.selector,
-                            static_method_name(node.method_name.to_s))
+          corrector.replace(node.loc.selector, static_method_name(node.method_name.to_s))
         end
 
         def autocorrect_argument_keywords(corrector, node, keywords)

data/lib/rubocop/cop/rails/enum_uniqueness.rb

@@ -20,8 +20,7 @@ module RuboCop
       class EnumUniqueness < Base
         include Duplication
 
-        MSG = 'Duplicate value `%<value>s` found in `%<enum>s` ' \
-              'enum declaration.'
+        MSG = 'Duplicate value `%<value>s` found in `%<enum>s` enum declaration.'
         RESTRICT_ON_SEND = %i[enum].freeze
 
         def_node_matcher :enum?, <<~PATTERN
@@ -41,9 +40,7 @@ module RuboCop
                 next unless duplicates?(items)
 
                 consecutive_duplicates(items).each do |item|
-                  add_offense(item, message: format(
-                    MSG, value: item.source, enum: enum_name(key)
-                  ))
+                  add_offense(item, message: format(MSG, value: item.source, enum: enum_name(key)))
                 end
               end
             end

data/lib/rubocop/cop/rails/environment_comparison.rb

@@ -96,8 +96,7 @@ module RuboCop
         end
 
         def rails_env_on_lhs?(node)
-          comparing_str_env_with_rails_env_on_lhs?(node) ||
-            comparing_sym_env_with_rails_env_on_lhs?(node)
+          comparing_str_env_with_rails_env_on_lhs?(node) || comparing_sym_env_with_rails_env_on_lhs?(node)
         end
 
         def build_predicate_method_for_rails_env_on_lhs(node)

data/lib/rubocop/cop/rails/file_path.rb

@@ -50,8 +50,7 @@ module RuboCop
           return unless node.children.last.str_type?
 
           last_child_source = node.children.last.source
-          return unless last_child_source.start_with?('.') ||
-                        last_child_source.include?(File::SEPARATOR)
+          return unless last_child_source.start_with?('.') || last_child_source.include?(File::SEPARATOR)
           return if last_child_source.start_with?(':')
 
           register_offense(node)
@@ -97,8 +96,7 @@ module RuboCop
 
         def register_offense(node)
           line_range = node.loc.column...node.loc.last_column
-          source_range = source_range(processed_source.buffer, node.first_line,
-                                      line_range)
+          source_range = source_range(processed_source.buffer, node.first_line, line_range)
           add_offense(source_range)
         end
 

data/lib/rubocop/cop/rails/find_each.rb

@@ -13,11 +13,17 @@ module RuboCop
       #   # good
       #   User.all.find_each
       #
-      # @example IgnoredMethods: ['order']
+      # @example AllowedMethods: ['order']
+      #   # good
+      #   User.order(:foo).each
+      #
+      # @example AllowedPattern: [/order/]
       #   # good
       #   User.order(:foo).each
       class FindEach < Base
         include ActiveRecordHelper
+        include AllowedMethods
+        include AllowedPattern
         extend AutoCorrector
 
         MSG = 'Use `find_each` instead of `each`.'
@@ -47,7 +53,7 @@ module RuboCop
 
           method_chain = node.each_node(:send).map(&:method_name)
 
-          (cop_config['IgnoredMethods'].map(&:to_sym) & method_chain).any?
+          method_chain.any? { |method_name| allowed_method?(method_name) || matches_allowed_pattern?(method_name) }
         end
 
         def active_model_error_where?(node)

data/lib/rubocop/cop/rails/freeze_time.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop
+    module Rails
+      # Identifies usages of `travel_to` with an argument of the current time and
+      # change them to use `freeze_time` instead.
+      #
+      # @safety
+      #   This cop’s autocorrection is unsafe because `freeze_time` just delegates to
+      #   `travel_to` with a default `Time.now`, it is not strictly equivalent to `Time.now`
+      #   if the argument of `travel_to` is the current time considering time zone.
+      #
+      # @example
+      #   # bad
+      #   travel_to(Time.now)
+      #   travel_to(Time.new)
+      #   travel_to(DateTime.now)
+      #   travel_to(Time.current)
+      #   travel_to(Time.zone.now)
+      #   travel_to(Time.now.in_time_zone)
+      #   travel_to(Time.current.to_time)
+      #
+      #   # good
+      #   freeze_time
+      #
+      class FreezeTime < Base
+        extend AutoCorrector
+
+        MSG = 'Use `freeze_time` instead of `travel_to`.'
+        NOW_METHODS = %i[now new current].freeze
+        CONV_METHODS = %i[to_time in_time_zone].freeze
+        RESTRICT_ON_SEND = %i[travel_to].freeze
+
+        # @!method time_now?(node)
+        def_node_matcher :time_now?, <<~PATTERN
+          (const nil? {:Time :DateTime})
+        PATTERN
+
+        # @!method zoned_time_now?(node)
+        def_node_matcher :zoned_time_now?, <<~PATTERN
+          (send (const nil? :Time) :zone)
+        PATTERN
+
+        def on_send(node)
+          child_node, method_name, time_argument = *node.first_argument.children
+          return if time_argument || !child_node
+          return unless current_time?(child_node, method_name) || current_time_with_convert?(child_node, method_name)
+
+          add_offense(node) do |corrector|
+            last_argument = node.last_argument
+            freeze_time_method = last_argument.block_pass_type? ? "freeze_time(#{last_argument.source})" : 'freeze_time'
+            corrector.replace(node, freeze_time_method)
+          end
+        end
+
+        private
+
+        def current_time?(node, method_name)
+          return false unless NOW_METHODS.include?(method_name)
+
+          node.send_type? ? zoned_time_now?(node) : time_now?(node)
+        end
+
+        def current_time_with_convert?(node, method_name)
+          return false unless CONV_METHODS.include?(method_name)
+
+          child_node, child_method_name = *node.children
+          current_time?(child_node, child_method_name)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/rails/has_many_or_has_one_dependent.rb

@@ -105,9 +105,7 @@ module RuboCop
 
             return false unless node.parent
 
-            return true if contain_valid_options_in_with_options_block?(
-              node.parent.parent
-            )
+            return true if contain_valid_options_in_with_options_block?(node.parent.parent)
           end
 
           false

data/lib/rubocop/cop/rails/http_positional_arguments.rb

@@ -22,11 +22,8 @@ module RuboCop
         extend AutoCorrector
         extend TargetRailsVersion
 
-        MSG = 'Use keyword arguments instead of ' \
-              'positional arguments for http call: `%<verb>s`.'
-        KEYWORD_ARGS = %i[
-          method params session body flash xhr as headers env to
-        ].freeze
+        MSG = 'Use keyword arguments instead of positional arguments for http call: `%<verb>s`.'
+        KEYWORD_ARGS = %i[method params session body flash xhr as headers env to].freeze
         ROUTING_METHODS = %i[draw routes].freeze
         RESTRICT_ON_SEND = %i[get post put patch delete head].freeze
 
@@ -75,8 +72,7 @@ module RuboCop
           return false if kwsplat_hash?(data)
 
           data.each_pair.none? do |pair|
-            special_keyword_arg?(pair.key) ||
-              (format_arg?(pair.key) && data.pairs.one?)
+            special_keyword_arg?(pair.key) || (format_arg?(pair.key) && data.pairs.one?)
           end
         end
 
@@ -98,8 +94,7 @@ module RuboCop
           return '' if data.hash_type? && data.empty?
 
           hash_data = if data.hash_type?
-                        format('{ %<data>s }',
-                               data: data.pairs.map(&:source).join(', '))
+                        format('{ %<data>s }', data: data.pairs.map(&:source).join(', '))
                       else
                         # user supplies an object,
                         # no need to surround with braces

data/lib/rubocop/cop/rails/http_status.rb

@@ -84,10 +84,8 @@ module RuboCop
 
         # :nodoc:
         class SymbolicStyleChecker
-          MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
-                'to define HTTP status code.'
-          DEFAULT_MSG = 'Prefer `symbolic` over `numeric` ' \
-                        'to define HTTP status code.'
+          MSG = 'Prefer `%<prefer>s` over `%<current>s` to define HTTP status code.'
+          DEFAULT_MSG = 'Prefer `symbolic` over `numeric` to define HTTP status code.'
 
           attr_reader :node
 
@@ -118,17 +116,14 @@ module RuboCop
           end
 
           def custom_http_status_code?
-            node.int_type? &&
-              !::Rack::Utils::SYMBOL_TO_STATUS_CODE.value?(number)
+            node.int_type? && !::Rack::Utils::SYMBOL_TO_STATUS_CODE.value?(number)
           end
         end
 
         # :nodoc:
         class NumericStyleChecker
-          MSG = 'Prefer `%<prefer>s` over `%<current>s` ' \
-                'to define HTTP status code.'
-          DEFAULT_MSG = 'Prefer `numeric` over `symbolic` ' \
-                        'to define HTTP status code.'
+          MSG = 'Prefer `%<prefer>s` over `%<current>s` to define HTTP status code.'
+          DEFAULT_MSG = 'Prefer `numeric` over `symbolic` to define HTTP status code.'
           PERMITTED_STATUS = %i[error success missing redirect].freeze
 
           attr_reader :node

data/lib/rubocop/cop/rails/ignored_skip_action_filter_option.rb

@@ -42,12 +42,7 @@ module RuboCop
           `%<ignore>s` option will be ignored when `%<prefer>s` and `%<ignore>s` are used together.
         MSG
 
-        RESTRICT_ON_SEND = %i[
-          skip_after_action
-          skip_around_action
-          skip_before_action
-          skip_action_callback
-        ].freeze
+        RESTRICT_ON_SEND = %i[skip_after_action skip_around_action skip_before_action skip_action_callback].freeze
 
         FILTERS = RESTRICT_ON_SEND.map { |method_name| ":#{method_name}" }
 
@@ -67,11 +62,9 @@ module RuboCop
           options = options_hash(options)
 
           if if_and_only?(options)
-            add_offense(options[:if],
-                        message: format(MSG, prefer: :only, ignore: :if))
+            add_offense(options[:if], message: format(MSG, prefer: :only, ignore: :if))
           elsif if_and_except?(options)
-            add_offense(options[:except],
-                        message: format(MSG, prefer: :if, ignore: :except))
+            add_offense(options[:except], message: format(MSG, prefer: :if, ignore: :except))
           end
         end
 

data/lib/rubocop/cop/rails/inverse_of.rb

@@ -192,8 +192,7 @@ module RuboCop
           end
           return if options_ignoring_inverse_of?(options)
 
-          return unless scope?(arguments) ||
-                        options_requiring_inverse_of?(options)
+          return unless scope?(arguments) || options_requiring_inverse_of?(options)
 
           return if options_contain_inverse_of?(options)
 
@@ -206,8 +205,7 @@ module RuboCop
 
         def options_requiring_inverse_of?(options)
           required = options.any? do |opt|
-            conditions_option?(opt) ||
-              foreign_key_option?(opt)
+            conditions_option?(opt) || foreign_key_option?(opt)
           end
 
           return required if target_rails_version >= 5.2
@@ -227,8 +225,7 @@ module RuboCop
 
         def with_options_arguments(recv, node)
           blocks = node.each_ancestor(:block).select do |block|
-            block.send_node.command?(:with_options) &&
-              same_context_in_with_options?(block.arguments.first, recv)
+            block.send_node.command?(:with_options) && same_context_in_with_options?(block.arguments.first, recv)
           end
           blocks.flat_map { |n| n.send_node.arguments }
         end

data/lib/rubocop/cop/rails/lexically_scoped_action_filter.rb

@@ -184,13 +184,9 @@ module RuboCop
         # @return [String]
         def message(methods, parent)
           if methods.size == 1
-            format(MSG,
-                   action: "`#{methods[0]}` is",
-                   type: parent.type)
+            format(MSG, action: "`#{methods[0]}` is", type: parent.type)
           else
-            format(MSG,
-                   action: "`#{methods.join('`, `')}` are",
-                   type: parent.type)
+            format(MSG, action: "`#{methods.join('`, `')}` are", type: parent.type)
           end
         end
       end

data/lib/rubocop/cop/rails/link_to_blank.rb

@@ -68,10 +68,7 @@ module RuboCop
 
         def append_to_rel(rel_node, corrector)
           existing_rel = rel_node.children.last.value
-          str_range = rel_node.children.last.loc.expression.adjust(
-            begin_pos: 1,
-            end_pos: -1
-          )
+          str_range = rel_node.children.last.loc.expression.adjust(begin_pos: 1, end_pos: -1)
           corrector.replace(str_range, "#{existing_rel} noopener")
         end
 

data/lib/rubocop/cop/rails/output.rb

@@ -21,11 +21,8 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG = 'Do not write to stdout. ' \
-              "Use Rails's logger if you want to log."
-        RESTRICT_ON_SEND = %i[
-          ap p pp pretty_print print puts binwrite syswrite write write_nonblock
-        ].freeze
+        MSG = "Do not write to stdout. Use Rails's logger if you want to log."
+        RESTRICT_ON_SEND = %i[ap p pp pretty_print print puts binwrite syswrite write write_nonblock].freeze
 
         def_node_matcher :output?, <<~PATTERN
           (send nil? {:ap :p :pp :pretty_print :print :puts} ...)

data/lib/rubocop/cop/rails/pluralization_grammar.rb

@@ -94,8 +94,7 @@ module RuboCop
         end
 
         def duration_method?(method_name)
-          SINGULAR_DURATION_METHODS.key?(method_name) ||
-            PLURAL_DURATION_METHODS.key?(method_name)
+          SINGULAR_DURATION_METHODS.key?(method_name) || PLURAL_DURATION_METHODS.key?(method_name)
         end
       end
     end

data/lib/rubocop/cop/rails/presence.rb

@@ -106,9 +106,7 @@ module RuboCop
         end
 
         def message(node, receiver, other)
-          format(MSG,
-                 prefer: replacement(receiver, other),
-                 current: node.source)
+          format(MSG, prefer: replacement(receiver, other), current: node.source)
         end
 
         def replacement(receiver, other)

data/lib/rubocop/cop/rails/present.rb

@@ -47,10 +47,8 @@ module RuboCop
         extend AutoCorrector
 
         MSG_NOT_BLANK = 'Use `%<prefer>s` instead of `%<current>s`.'
-        MSG_EXISTS_AND_NOT_EMPTY = 'Use `%<prefer>s` instead of ' \
-                                   '`%<current>s`.'
-        MSG_UNLESS_BLANK = 'Use `if %<prefer>s` instead of ' \
-                           '`%<current>s`.'
+        MSG_EXISTS_AND_NOT_EMPTY = 'Use `%<prefer>s` instead of `%<current>s`.'
+        MSG_UNLESS_BLANK = 'Use `if %<prefer>s` instead of `%<current>s`.'
         RESTRICT_ON_SEND = %i[!].freeze
 
         def_node_matcher :exists_and_not_empty?, <<~PATTERN
@@ -118,8 +116,7 @@ module RuboCop
 
           unless_blank?(node) do |method_call, receiver|
             range = unless_condition(node, method_call)
-            msg = format(MSG_UNLESS_BLANK, prefer: replacement(receiver),
-                                           current: range.source)
+            msg = format(MSG_UNLESS_BLANK, prefer: replacement(receiver), current: range.source)
             add_offense(range, message: msg) do |corrector|
               autocorrect(corrector, node)
             end

data/lib/rubocop/cop/rails/rake_environment.rb

@@ -39,7 +39,7 @@ module RuboCop
           (block $(send nil? :task ...) ...)
         PATTERN
 
-        def on_block(node)
+        def on_block(node) # rubocop:disable InternalAffairs/NumblockHandler
           task_definition?(node) do |task_method|
             return if task_name(task_method) == :default
             return if with_dependencies?(task_method)

data/lib/rubocop/cop/rails/redundant_allow_nil.rb

@@ -30,11 +30,9 @@ module RuboCop
         include RangeHelp
         extend AutoCorrector
 
-        MSG_SAME =
-          '`allow_nil` is redundant when `allow_blank` has the same value.'
+        MSG_SAME = '`allow_nil` is redundant when `allow_blank` has the same value.'
 
-        MSG_ALLOW_NIL_FALSE =
-          '`allow_nil: false` is redundant when `allow_blank` is true.'
+        MSG_ALLOW_NIL_FALSE = '`allow_nil: false` is redundant when `allow_blank` is true.'
 
         RESTRICT_ON_SEND = %i[validates].freeze
 

data/lib/rubocop/cop/rails/redundant_foreign_key.rb

@@ -41,7 +41,7 @@ module RuboCop
           association_with_foreign_key(node) do |type, name, options, foreign_key_pair, foreign_key|
             if redundant?(node, type, name, options, foreign_key)
               add_offense(foreign_key_pair.loc.expression) do |corrector|
-                range = range_with_surrounding_space(range: foreign_key_pair.source_range, side: :left)
+                range = range_with_surrounding_space(foreign_key_pair.source_range, side: :left)
                 range = range_with_surrounding_comma(range, :left)
 
                 corrector.remove(range)

data/lib/rubocop/cop/rails/redundant_presence_validation_on_belongs_to.rb

@@ -217,7 +217,7 @@ module RuboCop
           keys.each do |key|
             key_node = node.arguments.find { |arg| arg.value == key }
             key_range = range_with_surrounding_space(
-              range: range_with_surrounding_comma(key_node.source_range, :right),
+              range_with_surrounding_comma(key_node.source_range, :right),
               side: :right
             )
             corrector.remove(key_range)
@@ -226,7 +226,7 @@ module RuboCop
 
         def remove_presence_option(corrector, presence)
           range = range_with_surrounding_comma(
-            range_with_surrounding_space(range: presence.source_range, side: :left),
+            range_with_surrounding_space(presence.source_range, side: :left),
             :left
           )
           corrector.remove(range)

data/lib/rubocop/cop/rails/redundant_receiver_in_with_options.rb

@@ -60,15 +60,6 @@ module RuboCop
 
         MSG = 'Redundant receiver in `with_options`.'
 
-        def_node_matcher :with_options?, <<~PATTERN
-          (block
-            (send nil? :with_options
-              (...))
-            (args
-              $_arg)
-            $_body)
-        PATTERN
-
         def_node_search :all_block_nodes_in, <<~PATTERN
           (block ...)
         PATTERN
@@ -78,29 +69,40 @@ module RuboCop
         PATTERN
 
         def on_block(node)
-          with_options?(node) do |arg, body|
-            return if body.nil?
-            return unless all_block_nodes_in(body).count.zero?
-
-            send_nodes = all_send_nodes_in(body)
-
-            if send_nodes.all? { |n| same_value?(arg, n.receiver) }
-              send_nodes.each do |send_node|
-                receiver = send_node.receiver
-                add_offense(receiver.source_range) do |corrector|
-                  autocorrect(corrector, send_node)
-                end
-              end
+          return unless node.method?(:with_options)
+          return unless (body = node.body)
+          return unless all_block_nodes_in(body).count.zero?
+
+          send_nodes = all_send_nodes_in(body)
+          return unless redundant_receiver?(send_nodes, node)
+
+          send_nodes.each do |send_node|
+            receiver = send_node.receiver
+            add_offense(receiver.source_range) do |corrector|
+              autocorrect(corrector, send_node, node)
             end
           end
         end
 
+        alias on_numblock on_block
+
         private
 
-        def autocorrect(corrector, node)
-          corrector.remove(node.receiver.source_range)
-          corrector.remove(node.loc.dot)
-          corrector.remove(block_argument_range(node))
+        def autocorrect(corrector, send_node, node)
+          corrector.remove(send_node.receiver.source_range)
+          corrector.remove(send_node.loc.dot)
+          corrector.remove(block_argument_range(send_node)) unless node.numblock_type?
+        end
+
+        def redundant_receiver?(send_nodes, node)
+          proc = if node.numblock_type?
+                   ->(n) { n.receiver.lvar_type? && n.receiver.source == '_1' }
+                 else
+                   arg = node.arguments.first
+                   ->(n) { same_value?(arg, n.receiver) }
+                 end
+
+          send_nodes.all?(&proc)
         end
 
         def block_argument_range(node)

data/lib/rubocop/cop/rails/reflection_class_name.rb

@@ -34,12 +34,29 @@ module RuboCop
 
         def on_send(node)
           association_with_reflection(node) do |reflection_class_name|
+            return if reflection_class_name.value.send_type? && reflection_class_name.value.receiver.nil?
+            return if reflection_class_name.value.lvar_type? && str_assigned?(reflection_class_name)
+
             add_offense(reflection_class_name.loc.expression)
           end
         end
 
         private
 
+        def str_assigned?(reflection_class_name)
+          lvar = reflection_class_name.value.source
+
+          reflection_class_name.ancestors.each do |nodes|
+            return true if nodes.each_child_node(:lvasgn).detect do |node|
+              lhs, rhs = *node
+
+              lhs.to_s == lvar && ALLOWED_REFLECTION_CLASS_TYPES.include?(rhs.type)
+            end
+          end
+
+          false
+        end
+
         def reflection_class_value?(class_value)
           if class_value.send_type?
             !class_value.method?(:to_s) || class_value.receiver&.const_type?