feat: add alias refactor workspace command

lib/next_ls.ex

@@ -154,7 +154,8 @@ defmodule NextLS do
          execute_command_provider: %GenLSP.Structures.ExecuteCommandOptions{
            commands: [
              "to-pipe",
-             "from-pipe"
+             "from-pipe",
+             "alias-refactor"
            ]
          },
          hover_provider: true,
@@ -769,6 +770,19 @@ defmodule NextLS do
             position: position
           })
 
+        "alias-refactor" ->
+          [arguments] = params.arguments
+
+          uri = arguments["uri"]
+          position = arguments["position"]
+          text = lsp.assigns.documents[uri]
+
+          NextLS.Commands.Alias.run(%{
+            uri: uri,
+            text: text,
+            position: position
+          })
+
         _ ->
           NextLS.Logger.show_message(
             lsp.logger,
@@ -783,7 +797,7 @@ defmodule NextLS do
       %WorkspaceEdit{} = edit ->
         GenLSP.request(lsp, %WorkspaceApplyEdit{
           id: System.unique_integer([:positive]),
-          params: %ApplyWorkspaceEditParams{label: "Pipe", edit: edit}
+          params: %ApplyWorkspaceEditParams{label: NextLS.Commands.label(command), edit: edit}
         })
 
       _reply ->

lib/next_ls/commands.ex

@@ -0,0 +1,15 @@
+defmodule NextLS.Commands do
+  @moduledoc false
+
+  @labels %{
+    "from-pipe" => "Inlined pipe",
+    "to-pipe" => "Extracted to a pipe",
+    "alias-refactor" => "Refactored with an alias"
+  }
+  @doc "Creates a label for the workspace apply struct from the command name"
+  def label(command) when is_map_key(@labels, command), do: @labels[command]
+
+  def label(command) do
+    raise ArgumentError, "command #{inspect(command)} not supported"
+  end
+end

lib/next_ls/commands/alias.ex

@@ -0,0 +1,140 @@
+defmodule NextLS.Commands.Alias do
+  @moduledoc """
+  Refactors a module with fully qualified calls to an alias.
+  The cursor position should be under the module name that you wish to alias.
+  """
+  import Schematic
+
+  alias GenLSP.Enumerations.ErrorCodes
+  alias GenLSP.Structures.Position
+  alias GenLSP.Structures.Range
+  alias GenLSP.Structures.TextEdit
+  alias GenLSP.Structures.WorkspaceEdit
+  alias NextLS.ASTHelpers
+  alias NextLS.EditHelpers
+  alias Sourceror.Zipper, as: Z
+
+  @line_length 121
+
+  defp opts do
+    map(%{
+      position: Position.schematic(),
+      uri: str(),
+      text: list(str())
+    })
+  end
+
+  def run(opts) do
+    with {:ok, %{text: text, uri: uri, position: position}} <- unify(opts(), Map.new(opts)),
+         {:ok, ast, comments} = parse(text),
+         {:ok, defm} <- ASTHelpers.get_surrounding_module(ast, position),
+         {:ok, {:__aliases__, _, modules}} <- get_node(ast, position) do
+      range = make_range(defm)
+      indent = EditHelpers.get_indent(text, range.start.line)
+      aliased = get_aliased(defm, modules)
+
+      comments =
+        Enum.filter(comments, fn comment ->
+          comment.line > range.start.line && comment.line <= range.end.line
+        end)
+
+      to_algebra_opts = [comments: comments]
+      doc = Code.quoted_to_algebra(aliased, to_algebra_opts)
+      formatted = doc |> Inspect.Algebra.format(@line_length) |> IO.iodata_to_binary()
+
+      %WorkspaceEdit{
+        changes: %{
+          uri => [
+            %TextEdit{
+              new_text:
+                EditHelpers.add_indent_to_edit(
+                  formatted,
+                  indent
+                ),
+              range: range
+            }
+          ]
+        }
+      }
+    else
+      {:error, message} ->
+        %GenLSP.ErrorResponse{code: ErrorCodes.parse_error(), message: inspect(message)}
+    end
+  end
+
+  defp parse(lines) do
+    lines
+    |> Enum.join("\n")
+    |> Spitfire.parse_with_comments(literal_encoder: &{:ok, {:__block__, &2, [&1]}})
+    |> case do
+      {:error, ast, comments, _errors} ->
+        {:ok, ast, comments}
+
+      other ->
+        other
+    end
+  end
+
+  defp make_range(original_ast) do
+    range = Sourceror.get_range(original_ast)
+
+    %Range{
+      start: %Position{line: range.start[:line] - 1, character: range.start[:column] - 1},
+      end: %Position{line: range.end[:line] - 1, character: range.end[:column] - 1}
+    }
+  end
+
+  def get_node(ast, pos) do
+    pos = [line: pos.line + 1, column: pos.character + 1]
+
+    result =
+      ast
+      |> Z.zip()
+      |> Z.traverse(nil, fn tree, acc ->
+        node = Z.node(tree)
+        range = Sourceror.get_range(node)
+
+        if not is_nil(range) and
+             match?({:__aliases__, _context, _modules}, node) &&
+             Sourceror.compare_positions(range.start, pos) in [:lt, :eq] &&
+             Sourceror.compare_positions(range.end, pos) in [:gt, :eq] do
+          {tree, node}
+        else
+          {tree, acc}
+        end
+      end)
+
+    case result do
+      {_, nil} ->
+        {:error, "could not find a module to alias at the cursor position"}
+
+      {_, {_t, _m, []}} ->
+        {:error, "could not find a module to alias at the cursor position"}
+
+      {_, {_t, _m, [_argument | _rest]} = node} ->
+        {:ok, node}
+    end
+  end
+
+  defp get_aliased(defm, modules) do
+    last = List.last(modules)
+
+    replaced =
+      Macro.prewalk(defm, fn
+        {:__aliases__, context, ^modules} -> {:__aliases__, context, [last]}
+        ast -> ast
+      end)
+
+    alias_to_add = {:alias, [alias: false], [{:__aliases__, [], modules}]}
+
+    {:defmodule, context, [module, [{do_block, block}]]} = replaced
+
+    case block do
+      {:__block__, block_context, defs} ->
+        {:defmodule, context, [module, [{do_block, {:__block__, block_context, [alias_to_add | defs]}}]]}
+
+      {_, _, _} = original ->
+        {:defmodule, context, [module, [{do_block, {:__block__, [], [alias_to_add, original]}}]]}
+    end
+  end
+end

lib/next_ls/extensions/elixir_extension/code_action/require.ex

@@ -7,6 +7,7 @@ defmodule NextLS.ElixirExtension.CodeAction.Require do
   alias GenLSP.Structures.Range
   alias GenLSP.Structures.TextEdit
   alias GenLSP.Structures.WorkspaceEdit
+  alias NextLS.ASTHelpers
 
   @one_indentation_level "  "
   @spec new(diagnostic :: Diagnostic.t(), [text :: String.t()], uri :: String.t()) :: [CodeAction.t()]
@@ -15,7 +16,7 @@ defmodule NextLS.ElixirExtension.CodeAction.Require do
 
     with {:ok, require_module} <- get_edit(diagnostic.message),
          {:ok, ast} <- parse_ast(text),
-         {:ok, defm} <- nearest_defmodule(ast, range),
+         {:ok, defm} <- ASTHelpers.get_surrounding_module(ast, range.start),
          indentation <- get_indent(text, defm),
          nearest <- find_nearest_node_for_require(defm),
          range <- get_edit_range(nearest) do
@@ -47,27 +48,6 @@ defmodule NextLS.ElixirExtension.CodeAction.Require do
     |> Spitfire.parse()
   end
 
-  defp nearest_defmodule(ast, range) do
-    defmodules =
-      ast
-      |> Macro.prewalker()
-      |> Enum.filter(fn
-        {:defmodule, _, _} -> true
-        _ -> false
-      end)
-
-    if defmodules != [] do
-      defm =
-        Enum.min_by(defmodules, fn {_, ctx, _} ->
-          range.start.character - ctx[:line] + 1
-        end)
-
-      {:ok, defm}
-    else
-      {:error, "no defmodule definition"}
-    end
-  end
-
   @module_name ~r/require\s+([^\s]+)\s+before/
   defp get_edit(message) do
     case Regex.run(@module_name, message) do

lib/next_ls/helpers/ast_helpers.ex

@@ -1,5 +1,6 @@
 defmodule NextLS.ASTHelpers do
   @moduledoc false
+  alias GenLSP.Structures.Position
   alias Sourceror.Zipper
 
   defmodule Attributes do
@@ -154,6 +155,29 @@ defmodule NextLS.ASTHelpers do
     end)
   end
 
+  @spec get_surrounding_module(ast :: Macro.t(), position :: Position.t()) :: {:ok, Macro.t()} | {:error, String.t()}
+  def get_surrounding_module(ast, position) do
+    defm =
+      ast
+      |> Macro.prewalker()
+      |> Enum.filter(fn node -> match?({:defmodule, _, _}, node) end)
+      |> Enum.filter(fn {_, ctx, _} ->
+        position.line + 1 - ctx[:line] >= 0
+      end)
+      |> Enum.min_by(
+        fn {_, ctx, _} ->
+          abs(ctx[:line] - 1 - position.line)
+        end,
+        fn -> nil end
+      )
+
+    if defm do
+      {:ok, defm}
+    else
+      {:error, "no defmodule definition"}
+    end
+  end
+
   def find_cursor(ast) do
     with nil <-
            ast

test/next_ls/alias_test.exs

@@ -0,0 +1,91 @@
+defmodule NextLS.AliasTest do
+  use ExUnit.Case, async: true
+
+  import GenLSP.Test
+  import NextLS.Support.Utils
+
+  @moduletag :tmp_dir
+  @moduletag root_paths: ["my_proj"]
+
+  setup %{tmp_dir: tmp_dir} do
+    File.mkdir_p!(Path.join(tmp_dir, "my_proj/lib"))
+    File.write!(Path.join(tmp_dir, "my_proj/mix.exs"), mix_exs())
+
+    cwd = Path.join(tmp_dir, "my_proj")
+
+    foo_path = Path.join(cwd, "lib/foo.ex")
+
+    foo = """
+    defmodule Foo do
+      def to_list() do
+        Foo.Bar.to_list(Map.new())
+      end
+
+      def to_map() do
+        Foo.Bar.to_map(List.new())
+      end
+    end
+    """
+
+    File.write!(foo_path, foo)
+
+    [foo: foo, foo_path: foo_path]
+  end
+
+  setup :with_lsp
+
+  setup context do
+    assert :ok == notify(context.client, %{method: "initialized", jsonrpc: "2.0", params: %{}})
+    assert_is_ready(context, "my_proj")
+    assert_compiled(context, "my_proj")
+    assert_notification "$/progress", %{"value" => %{"kind" => "end", "message" => "Finished indexing!"}}
+
+    did_open(context.client, context.foo_path, context.foo)
+    context
+  end
+
+  test "refactors with alias", %{client: client, foo_path: foo} do
+    foo_uri = uri(foo)
+    id = 1
+
+    request client, %{
+      method: "workspace/executeCommand",
+      id: id,
+      jsonrpc: "2.0",
+      params: %{
+        command: "alias-refactor",
+        arguments: [%{uri: foo_uri, position: %{line: 2, character: 8}}]
+      }
+    }
+
+    expected_edit =
+      String.trim("""
+      defmodule Foo do
+        alias Foo.Bar
+
+        def to_list() do
+          Bar.to_list(Map.new())
+        end
+
+        def to_map() do
+          Bar.to_map(List.new())
+        end
+      end
+      """)
+
+    assert_request(client, "workspace/applyEdit", 500, fn params ->
+      assert %{"edit" => edit, "label" => "Refactored with an alias"} = params
+
+      assert %{
+               "changes" => %{
+                 ^foo_uri => [%{"newText" => text, "range" => range}]
+               }
+             } = edit
+
+      assert text == expected_edit
+
+      assert range["start"] == %{"character" => 0, "line" => 0}
+      assert range["end"] == %{"character" => 3, "line" => 8}
+    end)
+  end
+end