Use Document.Changes instead of CodeMod.Rename.DocumentChanges

apps/remote_control/lib/lexical/remote_control/code_mod/rename.ex

@@ -1,8 +1,8 @@
 defmodule Lexical.RemoteControl.CodeMod.Rename do
   alias Lexical.Ast.Analysis
+  alias Lexical.Document
   alias Lexical.Document.Position
   alias Lexical.Document.Range
-  alias Lexical.RemoteControl.CodeMod.Rename.DocumentChanges
   alias __MODULE__
 
   @spec prepare(Analysis.t(), Position.t()) ::
@@ -14,7 +14,7 @@ defmodule Lexical.RemoteControl.CodeMod.Rename do
   @rename_mapping %{module: Rename.Module}
 
   @spec rename(Analysis.t(), Position.t(), String.t()) ::
-          {:ok, [DocumentChanges.t()]} | {:error, term()}
+          {:ok, [Document.Changes.t()]} | {:error, term()}
   def rename(%Analysis{} = analysis, %Position{} = position, new_name) do
     case Rename.Prepare.resolve(analysis, position) do
       {:ok, {renamable, entity}, range} ->

apps/remote_control/lib/lexical/remote_control/code_mod/rename/module.ex

@@ -7,24 +7,22 @@ defmodule Lexical.RemoteControl.CodeMod.Rename.Module do
   alias Lexical.Document.Range
   alias Lexical.RemoteControl.CodeIntelligence.Entity
   alias Lexical.RemoteControl.CodeMod.Rename
-  alias Lexical.RemoteControl.CodeMod.Rename.DocumentChanges
   alias Lexical.RemoteControl.Search.Store
   require Logger
 
   import Line
 
-  @spec rename(Range.t(), String.t(), atom()) :: [DocumentChanges.t()]
+  @spec rename(Range.t(), String.t(), atom()) :: [Document.Changes.t()]
   def rename(%Range{} = old_range, new_name, entity) do
     {old_suffix, new_suffix} = old_range |> range_text() |> diff(new_name)
     results = exacts(entity, old_suffix) ++ descendants(entity, old_suffix)
 
-    results
-    |> Enum.group_by(&Document.Path.ensure_uri(&1.path))
-    |> Enum.map(fn {uri, entries} ->
-      rename_file = maybe_rename_file(entries, new_suffix)
-      edits = Enum.map(entries, &Edit.new(new_suffix, &1.range))
-      DocumentChanges.new(uri, edits, rename_file)
-    end)
+    for {uri, entries} <- Enum.group_by(results, &Document.Path.ensure_uri(&1.path)),
+        result = to_document_changes(uri, entries, new_suffix),
+        match?({:ok, _}, result) do
+      {:ok, document_changes} = result
+      document_changes
+    end
   end
 
   @spec resolve(Analysis.t(), Position.t()) ::
@@ -162,4 +160,13 @@ defmodule Lexical.RemoteControl.CodeMod.Rename.Module do
     |> put_in([:start, :character], start_character)
     |> put_in([:end, :character], end_character)
   end
+
+  defp to_document_changes(uri, entries, new_suffix) do
+    edits = Enum.map(entries, &Edit.new(new_suffix, &1.range))
+    rename_file = maybe_rename_file(entries, new_suffix)
+
+    with {:ok, document} <- Document.Store.open_temporary(uri) do
+      {:ok, Document.Changes.new(document, edits, rename_file)}
+    end
+  end
 end

apps/remote_control/test/lexical/remote_control/code_mod/rename_test.exs

@@ -469,13 +469,13 @@ defmodule Lexical.RemoteControl.CodeMod.RenameTest do
          {:ok, entries} <- Search.Indexer.Source.index(document.path, text),
          :ok <- Search.Store.replace(entries),
          analysis = Lexical.Ast.analyze(document),
-         {:ok, uri_with_changes} <- Rename.rename(analysis, position, new_name) do
-      changes = uri_with_changes |> Enum.map(& &1.edits) |> List.flatten()
+         {:ok, document_changes} <- Rename.rename(analysis, position, new_name) do
+      changes = document_changes |> Enum.map(& &1.edits) |> List.flatten()
       applied = apply_edits(document, changes)
 
       result =
         if path do
-          rename_file = uri_with_changes |> Enum.map(& &1.rename_file) |> List.first()
+          rename_file = document_changes |> Enum.map(& &1.rename_file) |> List.first()
           {applied, rename_file}
         else
           applied

apps/server/lib/lexical/server/provider/handlers/rename.ex

@@ -7,7 +7,6 @@ defmodule Lexical.Server.Provider.Handlers.Rename do
   alias Lexical.Protocol.Types.TextDocument
   alias Lexical.Protocol.Types.Workspace
   alias Lexical.RemoteControl.Api
-  alias Lexical.RemoteControl.CodeMod.Rename.DocumentChanges
   alias Lexical.Server.Provider.Env
   require Logger
 
@@ -29,8 +28,8 @@ defmodule Lexical.Server.Provider.Handlers.Rename do
 
       {:ok, results} ->
         text_document_edits =
-          Enum.map(results, fn %DocumentChanges{edits: edits, uri: uri} ->
-            new_text_document_edit(uri, edits)
+          Enum.map(results, fn %Document.Changes{edits: edits, document: document} ->
+            new_text_document_edit(document.uri, edits)
           end)
 
         rename_files =

apps/server/test/lexical/server/provider/handlers/rename_test.exs

@@ -4,7 +4,6 @@ defmodule Lexical.Server.Provider.Handlers.RenameTest do
   alias Lexical.Proto.Convert
   alias Lexical.Protocol.Requests.Rename
   alias Lexical.RemoteControl
-  alias Lexical.RemoteControl.CodeMod.Rename.DocumentChanges
 
   alias Lexical.Server
   alias Lexical.Server.Provider.Env
@@ -74,22 +73,24 @@ defmodule Lexical.Server.Provider.Handlers.RenameTest do
     end
 
     test "returns edit when there are changes", %{project: project, uri: uri} do
+      document = %Document{uri: uri, version: 0}
+
       patch(Document.Store, :fetch, fn ^uri, :analysis ->
         {:ok, nil, %Ast.Analysis{valid?: true}}
       end)
 
       patch(RemoteControl.Api, :rename, fn ^project, _analysis, _position, _new_name ->
         {:ok,
          [
-           DocumentChanges.new(
-             "file:///path/to/file.ex",
+           Document.Changes.new(
+             document,
              [
                %{
                  new_text: "new_text",
                  range: %{start: %{line: 1, character: 5}, end: %{line: 1, character: 10}}
                }
              ],
-             {"file:///path/to/file.ex", "file:///path/to/new_text.ex"}
+             {document.uri, "file:///path/to/new_text.ex"}
            )
          ]}
       end)
@@ -106,9 +107,9 @@ defmodule Lexical.Server.Provider.Handlers.RenameTest do
                }
              ]
 
-      assert edit.text_document.uri == "file:///path/to/file.ex"
+      assert edit.text_document.uri == document.uri
       assert edit.text_document.version == 0
-      assert rename_file.old_uri == "file:///path/to/file.ex"
+      assert rename_file.old_uri == document.uri
       assert rename_file.new_uri == "file:///path/to/new_text.ex"
     end
   end

projects/lexical_shared/lib/lexical/document/changes.ex

@@ -9,15 +9,17 @@ defmodule Lexical.Document.Changes do
   Using this struct allows efficient conversions at the language server border, as the document
   doesn't have to be looked up (and possibly read off the filesystem) by the language server.
   """
-  defstruct [:document, :edits]
+  defstruct [:document, :edits, :rename_file]
   alias Lexical.Document
 
   use Lexical.StructAccess
 
   @type edits :: Document.Edit.t() | [Document.Edit.t()]
+  @type rename_file :: nil | {Lexical.uri(), Lexical.uri()}
   @type t :: %__MODULE__{
           document: Document.t(),
-          edits: edits
+          edits: edits,
+          rename_file: rename_file()
         }
 
   @doc """
@@ -28,4 +30,9 @@ defmodule Lexical.Document.Changes do
   def new(document, edits) do
     %__MODULE__{document: document, edits: edits}
   end
+
+  @spec new(Document.t(), edits(), rename_file()) :: t()
+  def new(document, edits, rename_file) do
+    %__MODULE__{document: document, edits: edits, rename_file: rename_file}
+  end
 end