add replacing unknown function to code actions

Author: sheldak

apps/language_server/lib/language_server/providers/code_action.ex

@@ -1,25 +1,30 @@
 defmodule ElixirLS.LanguageServer.Providers.CodeAction do
   use ElixirLS.LanguageServer.Protocol
 
-  def code_actions(uri, diagnostics) do
+  alias ElixirLS.LanguageServer.SourceFile
+
+  @unknown_remote_function_pattern ~r/(.*)\/(.*) is undefined or private. .*:\n(.*)/s
+
+  def code_actions(uri, diagnostics, source_file) do
     actions =
       diagnostics
-      |> Enum.map(fn diagnostic -> actions(uri, diagnostic) end)
+      |> Enum.map(fn diagnostic -> actions(uri, diagnostic, source_file) end)
       |> List.flatten()
 
     {:ok, actions}
   end
 
-  defp actions(uri, %{"message" => message} = diagnostic) do
+  defp actions(uri, %{"message" => message} = diagnostic, source_file) do
     [
-      {~r/variable "(.*)" is unused/, &prefix_with_underscore/2},
-      {~r/variable "(.*)" is unused/, &remove_variable/2}
+      {~r/variable "(.*)" is unused/, &prefix_with_underscore/3},
+      {~r/variable "(.*)" is unused/, &remove_variable/3},
+      {@unknown_remote_function_pattern, &replace_unknown_function/3}
     ]
     |> Enum.filter(fn {r, _fun} -> String.match?(message, r) end)
-    |> Enum.map(fn {_r, fun} -> fun.(uri, diagnostic) end)
+    |> Enum.map(fn {_r, fun} -> fun.(uri, diagnostic, source_file) end)
   end
 
-  defp prefix_with_underscore(uri, %{"range" => range}) do
+  defp prefix_with_underscore(uri, %{"range" => range}, _source_file) do
     %{
       "title" => "Add '_' to unused variable",
       "kind" => "quickfix",
@@ -42,7 +47,7 @@ defmodule ElixirLS.LanguageServer.Providers.CodeAction do
     }
   end
 
-  defp remove_variable(uri, %{"range" => range}) do
+  defp remove_variable(uri, %{"range" => range}, _source_file) do
     %{
       "title" => "Remove unused variable",
       "kind" => "quickfix",
@@ -58,4 +63,62 @@ defmodule ElixirLS.LanguageServer.Providers.CodeAction do
       }
     }
   end
+
+  defp replace_unknown_function(uri, %{"message" => message, "range" => range}, source_file) do
+    [_, full_function_name, _function_arity, candidates_string] =
+      Regex.run(@unknown_remote_function_pattern, message)
+
+    function_module =
+      full_function_name
+      |> String.split(".")
+      |> Enum.slice(0..-2//1)
+      |> Enum.join(".")
+
+    start_line = start_line_from_range(range)
+
+    source_line =
+      source_file
+      |> SourceFile.lines()
+      |> Enum.at(start_line)
+
+    candidates_string
+    |> parse_candidates_string()
+    |> Enum.map(&(function_module <> "." <> &1))
+    |> Enum.reject(&(&1 == full_function_name))
+    |> Enum.map(fn full_candidate_name ->
+      %{
+        "title" => "Replace unknown function with '#{full_candidate_name}'",
+        "kind" => "quickfix",
+        "edit" => %{
+          "changes" => %{
+            uri => [
+              %{
+                "range" =>
+                  range(
+                    start_line,
+                    0,
+                    start_line,
+                    String.length(source_line)
+                  ),
+                "newText" => String.replace(source_line, full_function_name, full_candidate_name)
+              }
+            ]
+          }
+        }
+      }
+    end)
+  end
+
+  defp start_line_from_range(%{"start" => %{"line" => start_line}}), do: start_line
+
+  defp parse_candidates_string(str) do
+    pattern = ~r"[ ]*\* (?<function_name>.*)/.*"
+
+    str
+    |> String.split("\n")
+    |> Enum.map(&Regex.run(pattern, &1, capture: :all_names))
+    |> Enum.reject(&is_nil/1)
+    |> List.flatten()
+    |> Enum.uniq()
+  end
 end

apps/language_server/lib/language_server/server.ex

@@ -781,7 +781,9 @@ defmodule ElixirLS.LanguageServer.Server do
   end
 
   defp handle_request(code_action_req(_id, uri, diagnostics), state = %__MODULE__{}) do
-    {:async, fn -> CodeAction.code_actions(uri, diagnostics) end, state}
+    source_file = get_source_file(state, uri)
+
+    {:async, fn -> CodeAction.code_actions(uri, diagnostics, source_file) end, state}
   end
 
   defp handle_request(%{"method" => "$/" <> _}, state = %__MODULE__{}) do

apps/language_server/test/providers/code_action_test.exs

@@ -0,0 +1,75 @@
+defmodule ElixirLS.LanguageServer.Providers.CodeActionTest do
+  use ExUnit.Case
+
+  alias ElixirLS.LanguageServer.Providers.CodeAction
+  alias ElixirLS.LanguageServer.SourceFile
+
+  test "replace unknown function" do
+    uri = "file:///some_file.ex"
+
+    text = """
+    defmodule Example do
+      def foo do
+        var = Enum.counts([2, 3])
+      end
+    end
+    """
+
+    source_file = %SourceFile{text: text}
+
+    message = "Enum.counts/1 is undefined or private. Did you mean:
+
+    * concat/1
+    * concat/2
+    * count/1
+    * count/2
+    "
+
+    diagnostic = [
+      %{
+        "message" => message,
+        "range" => %{
+          "end" => %{"character" => 21, "line" => 2},
+          "start" => %{"character" => 10, "line" => 2}
+        },
+        "severity" => 2,
+        "source" => "Elixir"
+      }
+    ]
+
+    assert {:ok, [replace_with_concat, replace_with_count]} =
+             CodeAction.code_actions(uri, diagnostic, source_file)
+
+    assert %{
+             "edit" => %{
+               "changes" => %{
+                 ^uri => [
+                   %{
+                     "newText" => "    var = Enum.concat([2, 3])",
+                     "range" => %{
+                       "end" => %{"character" => 29, "line" => 2},
+                       "start" => %{"character" => 0, "line" => 2}
+                     }
+                   }
+                 ]
+               }
+             }
+           } = replace_with_concat
+
+    assert %{
+             "edit" => %{
+               "changes" => %{
+                 ^uri => [
+                   %{
+                     "newText" => "    var = Enum.count([2, 3])",
+                     "range" => %{
+                       "end" => %{"character" => 29, "line" => 2},
+                       "start" => %{"character" => 0, "line" => 2}
+                     }
+                   }
+                 ]
+               }
+             }
+           } = replace_with_count
+  end
+end

apps/language_server/test/providers/completion_test.exs

@@ -141,7 +141,9 @@ defmodule ElixirLS.LanguageServer.Providers.CompletionTest do
 
     {line, char} = {3, 17}
     TestUtils.assert_has_cursor_char(text, line, char)
-    {:ok, %{"items" => [first_suggestion | _tail]}} = Completion.completion(text, line, char, @supports)
+
+    {:ok, %{"items" => [first_suggestion | _tail]}} =
+      Completion.completion(text, line, char, @supports)
 
     assert first_suggestion["label"] === "fn"
   end