fix: __MODULE__ function calls support while renaming

Author: gp-pereira

lib/refactorex/refactor/function/rename_function.ex

@@ -12,6 +12,16 @@ defmodule Refactorex.Refactor.Function.RenameFunction do
   defguardp inside_range(min_args, max_args, num_args)
             when min_args <= num_args and num_args <= max_args
 
+  defmacrop module_call(name, meta, args) do
+    quote do: {{:., _, [{:__MODULE__, _, nil}, unquote(name)]}, unquote(meta), unquote(args)}
+  end
+
+  def can_refactor?(%{node: module_call(name, meta, args)} = zipper, selection) do
+    zipper
+    |> Z.replace({name, meta, args})
+    |> can_refactor?(selection)
+  end
+
   def can_refactor?(%{node: {name, meta, _}} = zipper, selection) do
     cond do
       not AST.equal?({name, meta, nil}, selection) ->
@@ -30,29 +40,42 @@ defmodule Refactorex.Refactor.Function.RenameFunction do
 
   def can_refactor?(_, _), do: false
 
+  def refactor(%{node: module_call(_, _, _)} = zipper, selection) do
+    zipper
+    |> replace_module_calls()
+    |> refactor(selection)
+  end
+
   def refactor(%{node: {name, _, _}} = zipper, _) do
-    [definition | _] = _definitions = Function.find_definitions(zipper)
+    [definition | _] = Function.find_definitions(zipper)
     {min_args, max_args} = Function.range_of_args(definition)
 
     zipper
     |> Module.go_to_scope()
+    |> replace_module_calls()
     |> Z.traverse_while(fn
-      %{node: {:|>, _, [_, {^name, meta, args}]}} = zipper
-      when inside_range(min_args, max_args, length(args) + 1) ->
-        {:cont,
-         zipper
-         |> Z.down()
-         |> Z.right()
-         |> Z.replace({placeholder(), meta, args})
-         |> Z.up()}
-
-      %{node: {:/, _, [{^name, meta, nil}, {:__block__, _, [num_args]}]}} = zipper
-      when inside_range(min_args, max_args, num_args) ->
-        {:cont,
-         zipper
-         |> Z.down()
-         |> Z.replace({placeholder(), meta, nil})
-         |> Z.up()}
+      %{node: {:|>, _, [_, {^name, meta, args}]}} = zipper ->
+        {:skip,
+         if inside_range(min_args, max_args, length(args) + 1) do
+           zipper
+           |> Z.down()
+           |> Z.right()
+           |> Z.replace({placeholder(), meta, args})
+           |> Z.up()
+         else
+           zipper
+         end}
+
+      %{node: {:/, _, [{^name, meta, args}, {:__block__, _, [num_args]}]}} = zipper ->
+        {:skip,
+         if inside_range(min_args, max_args, num_args) do
+           zipper
+           |> Z.down()
+           |> Z.replace({placeholder(), meta, args})
+           |> Z.up()
+         else
+           zipper
+         end}
 
       # zero arity function
       %{node: {^name, meta, args}} = zipper
@@ -66,5 +89,28 @@ defmodule Refactorex.Refactor.Function.RenameFunction do
       zipper ->
         {:cont, zipper}
     end)
+    |> bring_module_calls_back()
+  end
+
+  def replace_module_calls(zipper) do
+    Z.traverse(zipper, fn
+      %{node: module_call(name, meta, args)} = zipper ->
+        Z.replace(zipper, {name, Keyword.put(meta, :replaced, true), args})
+
+      zipper ->
+        zipper
+    end)
+  end
+
+  def bring_module_calls_back(zipper) do
+    Z.traverse(zipper, fn
+      %{node: {name, meta, args}} = zipper ->
+        if meta[:replaced],
+          do: Z.replace(zipper, {{:., [], [{:__MODULE__, [], nil}, name]}, meta, args}),
+          else: zipper
+
+      zipper ->
+        zipper
+    end)
   end
 end

test/refactor/function/rename_function_test.exs

@@ -133,6 +133,60 @@ defmodule Refactorex.Refactor.Function.RenameFunctionTest do
     )
   end
 
+  test "renames collapsed anonymous function" do
+    assert_refactored(
+      RenameFunction,
+      """
+      defmodule Foo do
+        #   v
+        def foo() do
+        #     ^
+          &foo/0
+          &foo/1
+        end
+      end
+      """,
+      """
+      defmodule Foo do
+        def #{placeholder()}() do
+          &#{placeholder()}/0
+          &foo/1
+        end
+      end
+      """
+    )
+  end
+
+  test "renames function called from __MODULE__" do
+    assert_refactored(
+      RenameFunction,
+      """
+      defmodule Foo do
+        def foo() do
+        #            v
+          __MODULE__.foo()
+        #              ^
+          __MODULE__.foo(10)
+          &__MODULE__.foo/0
+          &__MODULE__.foo/1
+          &__MODULE__.foo()
+        end
+      end
+      """,
+      """
+      defmodule Foo do
+        def #{placeholder()}() do
+          __MODULE__.#{placeholder()}()
+          __MODULE__.foo(10)
+          &__MODULE__.#{placeholder()}/0
+          &__MODULE__.foo/1
+          &__MODULE__.#{placeholder()}()
+        end
+      end
+      """
+    )
+  end
+
   test "renames the selected public function with multiple definitions" do
     assert_refactored(
       RenameFunction,