rubocop 1.71.1 → 1.91.0

data/lib/rubocop/cop/mixin.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module Cop # rubocop:disable Style/Documentation -- a namespace that only autoloads the mixins below
+    # Autoloads mixin modules included by cops. Mixins are autoloaded to reduce the number of
+    # requires because they're used only when the relevant cop class is loaded.
+
+    autoload :ArrayMinSize, "#{__dir__}/mixin/array_min_size"
+    autoload :ArraySyntax, "#{__dir__}/mixin/array_syntax"
+    autoload :Alignment, "#{__dir__}/mixin/alignment"
+    autoload :AllowedIdentifiers, "#{__dir__}/mixin/allowed_identifiers"
+    autoload :AllowedMethods, "#{__dir__}/mixin/allowed_methods"
+    autoload :AllowedPattern, "#{__dir__}/mixin/allowed_pattern"
+    autoload :AllowedReceivers, "#{__dir__}/mixin/allowed_receivers"
+    autoload :ForbiddenIdentifiers, "#{__dir__}/mixin/forbidden_identifiers"
+    autoload :ForbiddenPattern, "#{__dir__}/mixin/forbidden_pattern"
+    autoload :AutoCorrector, "#{__dir__}/mixin/auto_corrector" # rubocop:todo Naming/InclusiveLanguage -- the file is named `auto_corrector.rb`
+    autoload :CheckAssignment, "#{__dir__}/mixin/check_assignment"
+    autoload :CheckLineBreakable, "#{__dir__}/mixin/check_line_breakable"
+    autoload :CheckSingleLineSuitability, "#{__dir__}/mixin/check_single_line_suitability"
+    autoload :ConfigurableMax, "#{__dir__}/mixin/configurable_max"
+    autoload :CodeLength, "#{__dir__}/mixin/code_length"
+    autoload :ConfigurableEnforcedStyle, "#{__dir__}/mixin/configurable_enforced_style"
+    autoload :ConfigurableFormatting, "#{__dir__}/mixin/configurable_formatting"
+    autoload :ConfigurableNaming, "#{__dir__}/mixin/configurable_naming"
+    autoload :ConfigurableNumbering, "#{__dir__}/mixin/configurable_numbering"
+    autoload :DigHelp, "#{__dir__}/mixin/dig_help"
+    autoload :DocumentationComment, "#{__dir__}/mixin/documentation_comment"
+    autoload :Duplication, "#{__dir__}/mixin/duplication"
+    autoload :RangeHelp, "#{__dir__}/mixin/range_help"
+    autoload :ProjectIndexHelp, "#{__dir__}/mixin/project_index_help"
+    autoload :AnnotationComment, "#{__dir__}/mixin/annotation_comment"
+    autoload :EmptyParameter, "#{__dir__}/mixin/empty_parameter"
+    autoload :EndKeywordAlignment, "#{__dir__}/mixin/end_keyword_alignment"
+    autoload :EndlessMethodRewriter, "#{__dir__}/mixin/endless_method_rewriter"
+    autoload :EnforceSuperclass, "#{__dir__}/mixin/enforce_superclass"
+    autoload :FirstElementLineBreak, "#{__dir__}/mixin/first_element_line_break"
+    autoload :FrozenStringLiteral, "#{__dir__}/mixin/frozen_string_literal"
+    autoload :GemDeclaration, "#{__dir__}/mixin/gem_declaration"
+    autoload :GemspecHelp, "#{__dir__}/mixin/gemspec_help"
+    autoload :HashAlignmentStyles, "#{__dir__}/mixin/hash_alignment_styles"
+    autoload :HashSubset, "#{__dir__}/mixin/hash_subset"
+    autoload :HashTransformMethod, "#{__dir__}/mixin/hash_transform_method"
+    # Deprecated aliases of `AllowedMethods` and `AllowedPattern`, defined in those files.
+    autoload :IgnoredMethods, "#{__dir__}/mixin/allowed_methods"
+    autoload :IgnoredPattern, "#{__dir__}/mixin/allowed_pattern"
+    autoload :IndexedMethodArity, "#{__dir__}/mixin/indexed_method_arity"
+    autoload :IntegerNode, "#{__dir__}/mixin/integer_node"
+    autoload :Interpolation, "#{__dir__}/mixin/interpolation"
+    autoload :LineLengthHelp, "#{__dir__}/mixin/line_length_help"
+    autoload :MatchRange, "#{__dir__}/mixin/match_range"
+    autoload :HashShorthandSyntax, "#{__dir__}/mixin/hash_shorthand_syntax"
+    autoload :MethodComplexity, "#{__dir__}/mixin/method_complexity"
+    autoload :MethodPreference, "#{__dir__}/mixin/method_preference"
+    autoload :MinBodyLength, "#{__dir__}/mixin/min_body_length"
+    autoload :MinBranchesCount, "#{__dir__}/mixin/min_branches_count"
+    autoload :MultilineElementIndentation, "#{__dir__}/mixin/multiline_element_indentation"
+    autoload :MultilineElementLineBreaks, "#{__dir__}/mixin/multiline_element_line_breaks"
+    autoload :MultilineExpressionIndentation, "#{__dir__}/mixin/multiline_expression_indentation"
+    autoload :MultilineLiteralBraceLayout, "#{__dir__}/mixin/multiline_literal_brace_layout"
+    autoload :NegativeConditional, "#{__dir__}/mixin/negative_conditional"
+    autoload :Heredoc, "#{__dir__}/mixin/heredoc"
+    autoload :NilMethods, "#{__dir__}/mixin/nil_methods"
+    autoload :OnNormalIfUnless, "#{__dir__}/mixin/on_normal_if_unless"
+    autoload :OrderedGemNode, "#{__dir__}/mixin/ordered_gem_node"
+    autoload :Parentheses, "#{__dir__}/mixin/parentheses"
+    autoload :PercentArray, "#{__dir__}/mixin/percent_array"
+    autoload :PercentLiteral, "#{__dir__}/mixin/percent_literal"
+    autoload :PrecedingFollowingAlignment, "#{__dir__}/mixin/preceding_following_alignment"
+    autoload :PreferredDelimiters, "#{__dir__}/mixin/preferred_delimiters"
+    autoload :RationalLiteral, "#{__dir__}/mixin/rational_literal"
+    autoload :ReparsedEquivalence, "#{__dir__}/mixin/reparsed_equivalence"
+    autoload :RequireLibrary, "#{__dir__}/mixin/require_library"
+    autoload :RescueNode, "#{__dir__}/mixin/rescue_node"
+    autoload :SafeAssignment, "#{__dir__}/mixin/safe_assignment"
+    autoload :SpaceAfterPunctuation, "#{__dir__}/mixin/space_after_punctuation"
+    autoload :SpaceBeforePunctuation, "#{__dir__}/mixin/space_before_punctuation"
+    autoload :SurroundingSpace, "#{__dir__}/mixin/surrounding_space"
+    autoload :StatementModifier, "#{__dir__}/mixin/statement_modifier"
+    autoload :StringHelp, "#{__dir__}/mixin/string_help"
+    autoload :StringLiteralsHelp, "#{__dir__}/mixin/string_literals_help"
+    autoload :SymbolHelp, "#{__dir__}/mixin/symbol_help"
+    autoload :TargetRubyVersion, "#{__dir__}/mixin/target_ruby_version"
+    autoload :TrailingBody, "#{__dir__}/mixin/trailing_body"
+    autoload :TrailingComma, "#{__dir__}/mixin/trailing_comma"
+    autoload :UncommunicativeName, "#{__dir__}/mixin/uncommunicative_name"
+    autoload :VisibilityHelp, "#{__dir__}/mixin/visibility_help"
+    autoload :CommentsHelp, "#{__dir__}/mixin/comments_help"
+    autoload :DefNode, "#{__dir__}/mixin/def_node"
+  end
+end

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

@@ -11,6 +11,11 @@ module RuboCop
       # Getters (`get_attribute`) must have no arguments to be registered,
       # and setters (`set_attribute(value)`) must have exactly one.
       #
+      # When `AllCops/UseProjectIndex` is enabled and the `rubydex` gem is
+      # installed, methods that override a method defined by an ancestor
+      # elsewhere in the project are not reported, since renaming an override
+      # breaks the inherited contract.
+      #
       # @example
       #   # bad
       #   def set_attribute(value)
@@ -36,12 +41,15 @@ module RuboCop
       #   def set_value
       #   end
       class AccessorMethodName < Base
+        include ProjectIndexHelp
+
         MSG_READER = 'Do not prefix reader method names with `get_`.'
         MSG_WRITER = 'Do not prefix writer method names with `set_`.'
 
         def on_def(node)
           return unless proper_attribute_name?(node)
           return unless bad_reader_name?(node) || bad_writer_name?(node)
+          return if overrides_inherited_method?(node)
 
           message = message(node)
 
@@ -72,6 +80,22 @@ module RuboCop
             node.arguments.one? &&
             node.first_argument.arg_type?
         end
+
+        # When `AllCops/UseProjectIndex` is enabled, methods that override a
+        # method defined by an ancestor elsewhere in the project are not
+        # reported: renaming an override breaks the inherited contract.
+        def overrides_inherited_method?(node)
+          return false unless project_index
+          return false unless (namespace_node = node.each_ancestor(:class, :module).first)
+
+          declaration = resolve_constant_in_index(namespace_node.identifier)
+          return false unless declaration.is_a?(Rubydex::Namespace)
+
+          scope = node.defs_type? ? indexed_singleton_of(declaration) : declaration
+          !scope.nil? && inherited_index_member?(scope, "#{node.method_name}()")
+        rescue StandardError
+          false
+        end
       end
     end
   end

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

@@ -4,7 +4,7 @@ module RuboCop
   module Cop
     module Naming
       # Makes sure that certain binary operator methods have their
-      # sole  parameter named `other`.
+      # sole parameter named `other`.
       #
       # @example
       #
@@ -33,6 +33,7 @@ module RuboCop
               node.each_descendant(:lvar, :lvasgn) do |lvar|
                 lvar_location = lvar.loc.name
                 next unless lvar_location.source == arg.source
+                next if shadowed?(lvar, arg.source, node)
 
                 corrector.replace(lvar_location, 'other')
               end
@@ -47,6 +48,21 @@ module RuboCop
 
           !/\A[[:word:]]/.match?(name) || OP_LIKE_METHODS.include?(name)
         end
+
+        # A reference is shadowed when an enclosing block within the method redeclares the
+        # parameter name (as a block parameter or block-local). Such a reference points to
+        # the block's variable, not the operator's parameter, so it must not be renamed.
+        def shadowed?(node, name, def_node)
+          node.each_ancestor(:block).any? do |block|
+            def_node.source_range.contains?(block.source_range) && redeclares?(block, name)
+          end
+        end
+
+        def redeclares?(block, name)
+          block.arguments.any? do |argument|
+            argument.respond_to?(:name) && argument.name.to_s == name
+          end
+        end
       end
     end
   end

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

@@ -14,10 +14,10 @@ module RuboCop
       # autocorrected.
       #
       # [NOTE]
-      # --
+      # ====
       # Because of a bug in Ruby 3.3.0, when a block is referenced inside of another block,
       # no offense will be registered until Ruby 3.4:
-
+      #
       # [source,ruby]
       # ----
       # def foo(&block)
@@ -25,7 +25,7 @@ module RuboCop
       #   block_method { bar(&block) }
       # end
       # ----
-      # --
+      # ====
       #
       # @example EnforcedStyle: anonymous (default)
       #
@@ -62,7 +62,10 @@ module RuboCop
         MSG = 'Use %<style>s block forwarding.'
 
         def self.autocorrect_incompatible_with
-          [Lint::AmbiguousOperator, Style::ArgumentsForwarding, Style::ExplicitBlockArgument]
+          [
+            Lint::AmbiguousOperator, Style::ArgumentsForwarding,
+            Style::ExplicitBlockArgument, Style::MethodDefParentheses
+          ]
         end
 
         def on_def(node)

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

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

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

@@ -152,7 +152,7 @@ module RuboCop
 
             const_namespace, const_name = *const
             next if name != const_name && !match_acronym?(name, const_name)
-            next unless namespace.empty? || match_namespace(child, const_namespace, namespace)
+            next unless namespace.empty? || namespace_matches?(child, const_namespace, namespace)
 
             return node
           end
@@ -169,7 +169,7 @@ module RuboCop
           s(:const, namespace, name) if name
         end
 
-        def match_namespace(node, namespace, expected)
+        def namespace_matches?(node, namespace, expected)
           match_partial = partial_matcher!(expected)
 
           match_partial.call(namespace)
@@ -203,9 +203,10 @@ module RuboCop
 
         def match_acronym?(expected, name)
           expected = expected.to_s
-          name = name.to_s
-
-          allowed_acronyms.any? { |acronym| expected.gsub(acronym.capitalize, acronym) == name }
+          name = allowed_acronyms.reduce(name.to_s) do |result, acronym|
+            result.gsub(acronym, acronym.capitalize)
+          end
+          expected == name
         end
 
         def to_namespace(path) # rubocop:disable Metrics/AbcSize

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

@@ -91,6 +91,8 @@ module RuboCop
         end
 
         def on_new_investigation
+          return unless @flagged_terms_regex
+
           investigate_filepath if cop_config['CheckFilepaths']
           investigate_tokens
         end
@@ -144,7 +146,7 @@ module RuboCop
         def preprocess_flagged_terms
           allowed_strings = []
           flagged_term_strings = []
-          cop_config['FlaggedTerms'].each do |term, term_definition|
+          (cop_config['FlaggedTerms'] || {}).each do |term, term_definition|
             next if term_definition.nil?
 
             allowed_strings.concat(process_allowed_regex(term_definition['AllowedRegex']))
@@ -181,7 +183,11 @@ module RuboCop
         end
 
         def set_regexes(flagged_term_strings, allowed_strings)
-          @flagged_terms_regex = array_to_ignorecase_regex(flagged_term_strings)
+          # With no flagged terms an empty regex would match everything, so leave the
+          # regex nil and let `on_new_investigation` treat the cop as a no-op.
+          unless flagged_term_strings.empty?
+            @flagged_terms_regex = array_to_ignorecase_regex(flagged_term_strings)
+          end
           @allowed_regex = array_to_ignorecase_regex(allowed_strings) unless allowed_strings.empty?
         end
 

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

@@ -109,7 +109,7 @@ module RuboCop
       #     @_foo = calculate_expensive_thing
       #   end
       #
-      # @example EnforcedStyleForLeadingUnderscores :optional
+      # @example EnforcedStyleForLeadingUnderscores: optional
       #   # bad
       #   def foo
       #     @something ||= calculate_expensive_thing
@@ -167,13 +167,14 @@ module RuboCop
         PATTERN
 
         # rubocop:disable Metrics/AbcSize
-        # rubocop:disable Metrics/MethodLength
+        # rubocop:disable-next Metrics/MethodLength
         def on_or_asgn(node)
           lhs = node.lhs
           return unless lhs.ivasgn_type?
 
           method_node, method_name = find_definition(node)
           return unless method_node
+          return unless nameable_method?(method_name)
 
           body = method_node.body
           return unless body == node || body.children.last == node
@@ -191,7 +192,6 @@ module RuboCop
             corrector.replace(lhs.loc.name, "@#{suggested_var}")
           end
         end
-        # rubocop:enable Metrics/MethodLength
         # rubocop:enable Metrics/AbcSize
 
         # @!method defined_memoized?(node, ivar)
@@ -202,13 +202,14 @@ module RuboCop
             $(ivasgn %1 _))
         PATTERN
 
-        # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+        # rubocop:disable-next Metrics/AbcSize, Metrics/MethodLength
         def on_defined?(node)
           arg = node.first_argument
           return false unless arg.ivar_type?
 
           method_node, method_name = find_definition(node)
           return false unless method_node
+          return false unless nameable_method?(method_name)
 
           defined_memoized?(method_node.body, arg.name) do |defined_ivar, return_ivar, ivar_assign|
             return false if matches?(method_name, ivar_assign)
@@ -231,7 +232,6 @@ module RuboCop
             end
           end
         end
-        # rubocop:enable Metrics/AbcSize, Metrics/MethodLength
 
         private
 
@@ -242,7 +242,7 @@ module RuboCop
         def find_definition(node)
           # Methods can be defined in a `def` or `defs`,
           # or dynamically via a `block` node.
-          node.each_ancestor(:def, :defs, :block).each do |ancestor|
+          node.each_ancestor(:any_def, :block).each do |ancestor|
             method_node, method_name = method_definition?(ancestor)
             return [method_node, method_name] if method_node
           end
@@ -250,6 +250,13 @@ module RuboCop
           nil
         end
 
+        # Operator and other non-word method names (e.g. `[]`, `+`, `<=>`) cannot form a
+        # valid instance variable name, so there is no matching ivar to enforce and a
+        # suggested correction like `@[]` would be invalid Ruby.
+        def nameable_method?(method_name)
+          /\A[a-zA-Z_]\w*\z/.match?(method_name.to_s.delete('!?='))
+        end
+
         def matches?(method_name, ivar_assign)
           return true if ivar_assign.nil? || INITIALIZE_METHODS.include?(method_name)
 

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

@@ -6,14 +6,31 @@ module RuboCop
       # Makes sure that all methods use the configured style,
       # snake_case or camelCase, for their names.
       #
-      # This cop has `AllowedPatterns` configuration option.
+      # Method names matching patterns are always allowed.
       #
-      #   Naming/MethodName:
-      #     AllowedPatterns:
-      #       - '\AonSelectionBulkChange\z'
-      #       - '\AonSelectionCleared\z'
+      # The cop can be configured with `AllowedPatterns` to allow certain regexp patterns:
       #
-      # Method names matching patterns are always allowed.
+      # [source,yaml]
+      # ----
+      # Naming/MethodName:
+      #   AllowedPatterns:
+      #     - '\AonSelectionBulkChange\z'
+      #     - '\AonSelectionCleared\z'
+      # ----
+      #
+      # As well, you can also forbid specific method names or regexp patterns
+      # using `ForbiddenIdentifiers` or `ForbiddenPatterns`:
+      #
+      # [source,yaml]
+      # ----
+      # Naming/MethodName:
+      #   ForbiddenIdentifiers:
+      #     - 'def'
+      #     - 'super'
+      #   ForbiddenPatterns:
+      #     - '_v1\z'
+      #     - '_gen1\z'
+      # ----
       #
       # @example EnforcedStyle: snake_case (default)
       #   # bad
@@ -22,18 +39,79 @@ module RuboCop
       #   # good
       #   def foo_bar; end
       #
+      #   # bad
+      #   define_method :fooBar do
+      #   end
+      #
+      #   # good
+      #   define_method :foo_bar do
+      #   end
+      #
+      #   # bad
+      #   Struct.new(:fooBar)
+      #
+      #   # good
+      #   Struct.new(:foo_bar)
+      #
+      #   # bad
+      #   alias_method :fooBar, :some_method
+      #
+      #   # good
+      #   alias_method :foo_bar, :some_method
+      #
       # @example EnforcedStyle: camelCase
       #   # bad
       #   def foo_bar; end
       #
       #   # good
       #   def fooBar; end
+      #
+      #   # bad
+      #   define_method :foo_bar do
+      #   end
+      #
+      #   # good
+      #   define_method :fooBar do
+      #   end
+      #
+      #   # bad
+      #   Struct.new(:foo_bar)
+      #
+      #   # good
+      #   Struct.new(:fooBar)
+      #
+      #   # bad
+      #   alias_method :foo_bar, :some_method
+      #
+      #   # good
+      #   alias_method :fooBar, :some_method
+      #
+      # @example ForbiddenIdentifiers: ['def', 'super']
+      #   # bad
+      #   def def; end
+      #   def super; end
+      #
+      # @example ForbiddenPatterns: ['_v1\z', '_gen1\z']
+      #   # bad
+      #   def release_v1; end
+      #   def api_gen1; end
+      #
       class MethodName < Base
         include ConfigurableNaming
         include AllowedPattern
         include RangeHelp
+        include ForbiddenIdentifiers
+        include ForbiddenPattern
 
         MSG = 'Use %<style>s for method names.'
+        MSG_FORBIDDEN = '`%<identifier>s` is forbidden, use another method name instead.'
+        RESTRICT_ON_SEND = %i[
+          define_method define_singleton_method new define alias_method
+          attr attr_reader attr_writer attr_accessor
+        ].freeze
+
+        OPERATOR_METHODS = %i[| ^ & <=> == === =~ > >= < <= << >> + - * /
+                              % ** ~ +@ -@ !@ ~@ [] []= ! != !~ `].to_set.freeze
 
         # @!method sym_name(node)
         def_node_matcher :sym_name, '(sym $_name)'
@@ -41,35 +119,132 @@ module RuboCop
         # @!method str_name(node)
         def_node_matcher :str_name, '(str $_name)'
 
+        # @!method new_struct?(node)
+        def_node_matcher :new_struct?, '(send (const {nil? cbase} :Struct) :new ...)'
+
+        # @!method define_data?(node)
+        def_node_matcher :define_data?, '(send (const {nil? cbase} :Data) :define ...)'
+
         def on_send(node)
+          if node.method?(:define_method) || node.method?(:define_singleton_method)
+            handle_define_method(node)
+          elsif new_struct?(node)
+            handle_new_struct(node)
+          elsif define_data?(node)
+            handle_define_data(node)
+          elsif node.method?(:alias_method)
+            handle_alias_method(node)
+          else
+            handle_attr_accessor(node)
+          end
+        end
+
+        def on_def(node)
+          return if node.operator_method? || matches_allowed_pattern?(node.method_name)
+
+          if forbidden_name?(node.method_name.to_s)
+            register_forbidden_name(node)
+          else
+            check_name(node, node.method_name, node.loc.name)
+          end
+        end
+        alias on_defs on_def
+
+        def on_alias(node)
+          return unless (new_identifier = node.new_identifier).sym_type?
+
+          handle_method_name(new_identifier, new_identifier.value)
+        end
+
+        private
+
+        def handle_define_method(node)
+          return unless node.first_argument&.type?(:str, :sym)
+
+          handle_method_name(node, node.first_argument.value)
+        end
+
+        def handle_new_struct(node)
+          arguments = node.first_argument&.str_type? ? node.arguments[1..] : node.arguments
+          arguments.select { |argument| argument.type?(:sym, :str) }.each do |name|
+            handle_method_name(name, name.value)
+          end
+        end
+
+        def handle_define_data(node)
+          node.arguments.select { |argument| argument.type?(:sym, :str) }.each do |name|
+            handle_method_name(name, name.value)
+          end
+        end
+
+        def handle_alias_method(node)
+          return unless node.arguments.size == 2
+          return unless node.first_argument.type?(:str, :sym)
+
+          handle_method_name(node.first_argument, node.first_argument.value)
+        end
+
+        def handle_attr_accessor(node)
           return unless (attrs = node.attribute_accessor?)
 
           attrs.last.each do |name_item|
             name = attr_name(name_item)
             next if !name || matches_allowed_pattern?(name)
 
-            check_name(node, name, range_position(node))
+            if forbidden_name?(name.to_s)
+              register_forbidden_name(node)
+            else
+              check_name(node, name, range_position(node))
+            end
           end
         end
 
-        def on_def(node)
-          return if node.operator_method? || matches_allowed_pattern?(node.method_name)
+        def handle_method_name(node, name)
+          return if !name || matches_allowed_pattern?(name)
 
-          check_name(node, node.method_name, node.loc.name)
+          if forbidden_name?(name.to_s)
+            register_forbidden_name(node)
+          elsif !OPERATOR_METHODS.include?(name.to_sym)
+            check_name(node, name, range_position(node))
+          end
         end
-        alias on_defs on_def
 
-        private
+        def forbidden_name?(name)
+          forbidden_identifier?(name) || forbidden_pattern?(name)
+        end
+
+        # rubocop:disable-next Metrics/MethodLength, Metrics/AbcSize
+        def register_forbidden_name(node)
+          if node.any_def_type?
+            name_node = node.loc.name
+            method_name = node.method_name
+          elsif node.literal?
+            name_node = node
+            method_name = node.value
+          elsif (attrs = node.attribute_accessor?)
+            name_node = attrs.last.last
+            method_name = attr_name(name_node)
+          else
+            name_node = node.first_argument
+            method_name = node.first_argument.value
+          end
+          message = format(MSG_FORBIDDEN, identifier: method_name)
+          add_offense(name_node, message: message)
+        end
 
         def attr_name(name_item)
           sym_name(name_item) || str_name(name_item)
         end
 
         def range_position(node)
-          selector_end_pos = node.loc.selector.end_pos + 1
-          expr_end_pos = node.source_range.end_pos
+          if node.loc?(:selector)
+            selector_end_pos = node.loc.selector.end_pos + 1
+            expr_end_pos = node.source_range.end_pos
 
-          range_between(selector_end_pos, expr_end_pos)
+            range_between(selector_end_pos, expr_end_pos)
+          else
+            node.source_range
+          end
         end
 
         def message(style)