Fix false positives for Lint/DuplicateMethods when the self-alias trick is used

viralpraxis · bbatsov · commit 2508d948bb56 · 2025-07-08T09:58:19.000+03:00
When there's a self alias, there's no need to register an offense:

```ruby
class a
  alias foo foo
  # or alias_method :foo, :foo
  def foo; end
```

Using the alias-self trick indicates that developer is trying to avoid
"method redefinition" warning.
diff --git a/changelog/fix_false_positives_for_lint_duplicate_methods_20250618124754.md b/changelog/fix_false_positives_for_lint_duplicate_methods_20250618124754.md
@@ -0,0 +1 @@
+* [#14300](https://github.com/rubocop/rubocop/pull/14300): Fix false positives for `Lint/DuplicateMethods` cop when self-alias trick is used. ([@viralpraxis][])
diff --git a/lib/rubocop/cop/lint/duplicate_methods.rb b/lib/rubocop/cop/lint/duplicate_methods.rb
@@ -5,6 +5,9 @@ module Cop
     module Lint
       # Checks for duplicated instance (or singleton) method
       # definitions.
+      # NOTE: Aliasing a method to itself is allowed, as it indicates that
+      # the developer intends to suppress Ruby's method redefinition warnings.
+      # See https://bugs.ruby-lang.org/issues/13574.
       #
       # @example
       #
@@ -40,6 +43,18 @@ module Lint
       #
       #   alias bar foo
       #
+      #   # good
+      #   alias foo foo
+      #   def foo
+      #     1
+      #   end
+      #
+      #   # good
+      #   alias_method :foo, :foo
+      #   def foo
+      #     1
+      #   end
+      #
       # @example AllCops:ActiveSupportExtensionsEnabled: false (default)
       #
       #   # good
@@ -113,19 +128,21 @@ def on_defs(node)
 
         # @!method method_alias?(node)
         def_node_matcher :method_alias?, <<~PATTERN
-          (alias (sym $_name) sym)
+          (alias (sym $_name) (sym $_original_name))
         PATTERN
 
         def on_alias(node)
-          return unless (name = method_alias?(node))
+          name, original_name = method_alias?(node)
+          return unless name && original_name
+          return if name == original_name
           return if node.ancestors.any?(&:if_type?)
 
           found_instance_method(node, name)
         end
 
         # @!method alias_method?(node)
         def_node_matcher :alias_method?, <<~PATTERN
-          (send nil? :alias_method (sym $_name) _)
+          (send nil? :alias_method (sym $_name) (sym $_original_name))
         PATTERN
 
         # @!method delegate_method?(node)
@@ -140,7 +157,10 @@ def on_alias(node)
         def_node_matcher :sym_name, '(sym $_name)'
 
         def on_send(node) # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-          if (name = alias_method?(node))
+          name, original_name = alias_method?(node)
+
+          if name && original_name
+            return if name == original_name
             return if node.ancestors.any?(&:if_type?)
 
             found_instance_method(node, name)
diff --git a/spec/rubocop/cop/lint/duplicate_methods_spec.rb b/spec/rubocop/cop/lint/duplicate_methods_spec.rb
@@ -261,6 +261,17 @@ def some_method
       RUBY
     end
 
+    it "does not register an offense for duplicate self-alias in #{type}" do
+      expect_no_offenses(<<~RUBY, 'example.rb')
+        #{opening_line}
+          alias some_method some_method
+          def some_method
+            implement 1
+          end
+        end
+      RUBY
+    end
+
     it "doesn't register an offense for non-duplicate alias in #{type}" do
       expect_no_offenses(<<~RUBY)
         #{opening_line}
@@ -284,6 +295,28 @@ def some_method
       RUBY
     end
 
+    it "does not register an offense for duplicate self-alias_method in #{type}" do
+      expect_no_offenses(<<~RUBY, 'example.rb')
+        #{opening_line}
+          alias_method :some_method, :some_method
+          def some_method
+            implement 1
+          end
+        end
+      RUBY
+    end
+
+    it "does not register an offense for duplicate self-alias_method with dynamic original name in #{type}" do
+      expect_no_offenses(<<~RUBY, 'example.rb')
+        #{opening_line}
+          alias_method :some_method, unknown()
+          def some_method
+            implement 1
+          end
+        end
+      RUBY
+    end
+
     it "accepts for non-duplicate alias_method in #{type}" do
       expect_no_offenses(<<~RUBY)
         #{opening_line}

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1 @@`
	`1`	+* [#14300](https://github.com/rubocop/rubocop/pull/14300): Fix false positives for `Lint/DuplicateMethods` cop when self-alias trick is used. ([@viralpraxis][])