Add Support for `Renaming module` #374

scottming · 2023-09-17T08:22:19Z

We need to consider two typical scenarios:

One is renaming an exact entry,
And the other is renaming both the entry and its descendants.

I differentiate between these two scenarios based on the cursor's position. If there are no more child modules after the cursor, for example, in the case of defmodule TopLevel.|Entry, then rename the Entry module.

However, if there are child modules after the cursor, then rename both the Entry module and its descendants.
For example, if the cursor is at defmodule TopLevel.|Entry.Child, and we want to rename it to defmodule TopLevel.Renamed.Child, then TopLevel.Entry.AnotherChild will also be renamed to TopLevel.Renamed.AnotherChild

TODO

Add some tests for handlers/rename.ex

apps/remote_control/lib/lexical/remote_control/code_intelligence/entity.ex

zachallaun

Haven't finished review yet, but have to run for a bit and wanted to get this thought down: Does this handle renaming an alias? For instance, if I have:

alias Future.Code, as: Code

And then I want to rename Code to MyFutureCode (contrived example), the rename should only occur within the scope that the alias is valid. I think this is probably something that needs to be handled/considered by the indexer -- just want to make sure it is.

apps/server/lib/lexical/server/iex/helpers.ex

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

zachallaun · 2023-09-17T13:56:19Z

Please ignore this:

Does this handle renaming an alias?

Made my way to the tests and I see that it does :) Apologies for not reading those first.

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

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

scottming · 2023-12-04T13:25:08Z

I think this pull request is ready for review. The core of the renaming process is to identify eligible candidates, adjust the range, and combine them into a structure of %{ uri => changes }. @scohen @zachallaun

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

zachallaun · 2023-12-04T20:14:06Z

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

+  defp resolve_entity_range(uri, location, entity) do
+    {line, character} = location
+
+    with {:ok, document} <- Document.Store.open_temporary(uri),
+         position = Position.new(document, line, character),
+         analysis = Ast.analyze(document),
+         {:ok, result, range} <- resolve_module(analysis, position) do


We can make sure that analysis is cached using the new document store derived data. Assuming the other suggestions I made are incorporated:

Suggested change

defp resolve_entity_range(uri, location, entity) do

{line, character} = location

with {:ok, document} <- Document.Store.open_temporary(uri),

position = Position.new(document, line, character),

analysis = Ast.analyze(document),

{:ok, result, range} <- resolve_module(analysis, position) do

defp resolve_entity_range(uri, position, entity) do

with {:ok, _} <- Document.Store.open_temporary(uri),

{:ok, document, analysis} <- Document.Store.fetch(uri, :analysis),

{:ok, result, range} <- Entity.resolve(analysis, position, [:module, :struct]) do

We need to be sure that the analysis is also purged when a temporarily opened document is closed.

@scohen Does this point relate to this PR? I don't quite understand this comment. Could you elaborate?

zachallaun · 2023-12-05T14:02:03Z

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

+  @spec rename(Analysis.t(), Position.t(), String.t()) ::
+          {:ok, %{Lexical.uri() => [Edit.t()]}} | {:error, term()}
+  def rename(%Analysis{} = analysis, %Position{} = position, new_name) do
+    with {:ok, entity, range} <- resolve_module(analysis, position) do


What do you think about replacing resolve_module with a new Entity.resolve/3 API that would work like:

Suggested change

with {:ok, entity, range} <- resolve_module(analysis, position) do

with {:ok, entity, range} <- Entity.resolve(analysis, position, [:module, :struct]) do

Inside Entity, I think the implementation would just be:

def resolve(%Analysis{} = analysis, %Position{} = position, kinds) when is_list(kinds) do case resolve(analysis, position) do {:error, _} = error -> error entity when is_tuple(entity) and elem(entity, 0) in kinds -> entity _ -> {:error, :not_found} end end

I think we can do this in the future, but for now, I prefer to keep it in this file, as this API is not used elsewhere.

zachallaun · 2023-12-05T14:10:02Z

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

+          |> Enum.filter(fn result ->
+            range_text = range_text(result.range)
+            String.contains?(range_text, cursor_entity_string)
+          end)


This particular filter happens at least three times in this file, I think -- probably worth extracting into a helper.

Suggested change

|> Enum.filter(fn result ->

range_text = range_text(result.range)

String.contains?(range_text, cursor_entity_string)

end)

|> entries_matching(cursor_entity_string)

haha, Just twice, but I prefer to abstract a function for the item

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

zachallaun · 2023-12-05T14:18:43Z

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

+  setup_all do
+    project = project()
+    RemoteControl.set_project(project)
+    start_supervised!(Document.Store)


This will be necessary to use Document.Store.fetch(uri, :analysis) as I suggested elsewhere.

Suggested change

start_supervised!(Document.Store)

start_supervised!(Lexical.Server.Application.document_store_child_spec())

good suggestion, but we can't simply use that function because currently in the remote_control app context.

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

scottming · 2023-12-09T10:41:20Z

PrepareRename and Rename in Vscode

CleanShot.2023-12-09.at.18.33.47.mp4

in Neovim

CleanShot.2023-12-09.at.18.31.30-converted.mp4

@zachallaun I've applied most of your suggestions. Please review them again when you have time. If there are no other issues, then I will add some integration tests for the handlers.

scohen

My main concern her is if we could simplify things by making subjects charlists.

scohen · 2023-12-09T01:01:17Z

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

+    # Users won't always want to rename descendants of a module.
+    # For instance, when there are no more submodules after the cursor.
+    # like: `defmodule TopLevel.Mo|dule do`
+    # in most cases, users only want to rename the module itself.
+    #
+    # However, there's an exception when the cursor is in the middle,
+    # such as `Top.Mo|dule.ChildModule`. If we rename it to `Top.Renamed.Child`,
+    # it would be natural to also rename `Module.ChildModule` to `Renamed.Child`.


shouldn't you figure out which canonical module you want to rename, and find all instances of that? Possibly using a substring match that we'd have to build. Then it's just a matter of doing Store.starts_with("Foo.Bar.Baz", :module)

scohen · 2023-12-11T16:22:23Z

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

+  defp cursor_entity_string(range) do
+    # Parent.|Module -> Module
+    range
+    |> range_text()
+    |> String.split(".")
+    |> List.last()
+  end


this should go in ast/module.ex, and should be called something like: local_module_name

scohen · 2023-12-11T16:25:37Z

apps/remote_control/lib/lexical/remote_control/search/store/backends/ets/schemas/v1.ex

+  defkey :by_prefix, [
+    :prefix,
+    :type,
+    :subtype,
+    :elixir_version,
+    :erlang_version
+  ]


you added a key and a field, you need to increment the schema and make a migration.

Are you referring to the "subject" in the key or the "subject" in the value? I think if we change the "subject" in the "by_subject" record key to a charlist instead of a binary, it would also achieve this goal. Currently, it is a binary.

lexical/apps/remote_control/lib/lexical/remote_control/search/store/backends/ets/schemas/v1.ex

Line 59 in 2b266ea

subject: to_subject(entry.subject),

what we really need is something like this:

{:by_prefix, [70, 111, 111, 46, 66, 97, 114 | :_], :module, :definition, "1.15.7", "25.3.2.7"}

no matter is by_prefix or by_subject

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

scohen · 2023-12-11T16:58:22Z

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

+  end
+
+  describe "rename struct" do
+    test "succeeds when the cursor on the definition" do


Suggested change

test "succeeds when the cursor on the definition" do

test "succeeds when the cursor is before the definition" do

Should it though?

When we hover, before the first letter of the definition, it returns the module. So, it is reasonable here. In this case, I think using "at" instead of "before" would be more appropriate.

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

scohen · 2023-12-11T17:12:47Z

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

+        end
+      ] |> rename("Renamed")
+
+      refute result =~ ~S[defmodule TopLevel.Renamed.Another]


i would definitely expect the module Toplevel.Module.Another to be renamed to Toplevel.Renamed.Another

Here, I would like to preserve the functionality of renaming an exact module.

Consider the following scenario: Let's say we have two modules, Project.Schema.User and Project.Schema. If we find that Project.Schema is not clear in its meaning and rename it to Project.EctoHelper, should we also rename Project.Schema.User to Project.EctoHelper.User?

I believe the answer is no. Clearly, there are times when we want to rename a specific module, and there are times when we want to rename all modules that have that module as a prefix.

scottming · 2023-12-31T06:47:16Z

@scohen I have applied almost all of your suggestions. Please take the time to review this PR again, especially the two commits related to the schema.

scottming · 2024-02-10T01:29:28Z

It can only simplify part of things, but I think I can split this PR into multiple PRs.

…mplementation, we have made two changes: 1. We constrained the scope of renaming, meaning that renaming a module is only allowed at its definition. This simplification reduces a lot of computations. 2. Based on the first point, our preparation no longer returns just a single local module, but instead, the entire module. This means that module renaming has become more powerful. We can not only rename a single local module but also simplify a module. For example, renaming TopLevel.Parent.Child to TopLevel.Child, or renaming some middle parts, like TopLevel.Parent.Child to TopLevel.Renamed. I personally really like this change, especially the second point, which makes module renaming much more practical.

… previous implementation, we have made two changes: 1. We constrained the scope of renaming, meaning that renaming a module is only allowed at its definition. This simplification reduces a lot of computations. 2. Based on the first point, our preparation no longer returns just a single local module, but instead, the entire module. This means that module renaming has become more powerful. We can not only rename a single local module but also simplify a module. For example, renaming TopLevel.Parent.Child to TopLevel.Child, or renaming some middle parts, like TopLevel.Parent.Child to TopLevel.Renamed. I personally really like this change, especially the second point, which makes module renaming much more practical.

…mplementation, we have made two changes: 1. We constrained the scope of renaming, meaning that renaming a module is only allowed at its definition. This simplification reduces a lot of computations. 2. Based on the first point, our preparation no longer returns just a single local module, but instead, the entire module. This means that module renaming has become more powerful. We can not only rename a single local module but also simplify a module. For example, renaming TopLevel.Parent.Child to TopLevel.Child, or renaming some middle parts, like TopLevel.Parent.Child to TopLevel.Renamed. I personally really like this change, especially the second point, which makes module renaming much more practical.

Enhanced the application by integrating rename functionality, increasing its editing capabilities. This includes supporting the preparation and execution of rename operations in various modules such as the lexical AST module, protocol request and response modules, remote control API, and server provider handling. Key additions entail aliasing for easier reference, handling new rename-related requests and responses, and implementing server state updates to acknowledge rename capabilities. The changes underscore our dedication to improving the tool's utility and ensuring a more dynamic and responsive user experience in code manipulation scenarios. Filter out the `:struct` type references Add some handler tests for `rename` Add doc for `local_module_name` Move `rename` from `code_intelligence` to `code_mod` Move the prepare logic to a individual module This PR is primarily copied from #374, but compared to the previous implementation, we have made two changes: 1. We constrained the scope of renaming, meaning that renaming a module is only allowed at its definition. This simplification reduces a lot of computations. 2. Based on the first point, our preparation no longer returns just a single local module, but instead, the entire module. This means that module renaming has become more powerful. We can not only rename a single local module but also simplify a module. For example, renaming TopLevel.Parent.Child to TopLevel.Child, or renaming some middle parts, like TopLevel.Parent.Child to TopLevel.Renamed. I personally really like this change, especially the second point, which makes module renaming much more practical. Surround the whole module when renaming happens Remove logic related to the rename function. Apply some code review suggestions

Enhanced the application by integrating rename functionality, increasing its editing capabilities. This includes supporting the preparation and execution of rename operations in various modules such as the lexical AST module, protocol request and response modules, remote control API, and server provider handling. Key additions entail aliasing for easier reference, handling new rename-related requests and responses, and implementing server state updates to acknowledge rename capabilities. The changes underscore our dedication to improving the tool's utility and ensuring a more dynamic and responsive user experience in code manipulation scenarios. Filter out the `:struct` type references Add some handler tests for `rename` Add doc for `local_module_name` Move `rename` from `code_intelligence` to `code_mod` Move the prepare logic to a individual module This PR is primarily copied from #374, but compared to the previous implementation, we have made two changes: 1. We constrained the scope of renaming, meaning that renaming a module is only allowed at its definition. This simplification reduces a lot of computations. 2. Based on the first point, our preparation no longer returns just a single local module, but instead, the entire module. This means that module renaming has become more powerful. We can not only rename a single local module but also simplify a module. For example, renaming TopLevel.Parent.Child to TopLevel.Child, or renaming some middle parts, like TopLevel.Parent.Child to TopLevel.Renamed. I personally really like this change, especially the second point, which makes module renaming much more practical. Surround the whole module when renaming happens Remove logic related to the rename function. Apply some code review suggestions Fix a bug when expanding the module Fix a merge error Apply a format module usage suggestion Update apps/remote_control/lib/lexical/remote_control/code_mod/rename.ex Co-authored-by: Steve Cohen <[email protected]> Apply the `defdelegate` suggestion Fix a bug when the descendant containing the old suffix

Enhanced the application by integrating rename functionality, increasing its editing capabilities. This includes supporting the preparation and execution of rename operations in various modules such as the lexical AST module, protocol request and response modules, remote control API, and server provider handling. Key additions entail aliasing for easier reference, handling new rename-related requests and responses, and implementing server state updates to acknowledge rename capabilities. The changes underscore our dedication to improving the tool's utility and ensuring a more dynamic and responsive user experience in code manipulation scenarios. Filter out the `:struct` type references Add some handler tests for `rename` Add doc for `local_module_name` Move `rename` from `code_intelligence` to `code_mod` Move the prepare logic to a individual module This PR is primarily copied from lexical-lsp#374, but compared to the previous implementation, we have made two changes: 1. We constrained the scope of renaming, meaning that renaming a module is only allowed at its definition. This simplification reduces a lot of computations. 2. Based on the first point, our preparation no longer returns just a single local module, but instead, the entire module. This means that module renaming has become more powerful. We can not only rename a single local module but also simplify a module. For example, renaming TopLevel.Parent.Child to TopLevel.Child, or renaming some middle parts, like TopLevel.Parent.Child to TopLevel.Renamed. I personally really like this change, especially the second point, which makes module renaming much more practical. Surround the whole module when renaming happens Remove logic related to the rename function. Apply some code review suggestions Fix a bug when expanding the module Fix a merge error Apply a format module usage suggestion Update apps/remote_control/lib/lexical/remote_control/code_mod/rename.ex Co-authored-by: Steve Cohen <[email protected]> Apply the `defdelegate` suggestion Fix a bug when the descendant containing the old suffix

Enhanced the application by integrating rename functionality, increasing its editing capabilities. This includes supporting the preparation and execution of rename operations in various modules such as the lexical AST module, protocol request and response modules, remote control API, and server provider handling. Key additions entail aliasing for easier reference, handling new rename-related requests and responses, and implementing server state updates to acknowledge rename capabilities. The changes underscore our dedication to improving the tool's utility and ensuring a more dynamic and responsive user experience in code manipulation scenarios. Filter out the `:struct` type references Add some handler tests for `rename` Add doc for `local_module_name` Move `rename` from `code_intelligence` to `code_mod` Move the prepare logic to a individual module This PR is primarily copied from #374, but compared to the previous implementation, we have made two changes: 1. We constrained the scope of renaming, meaning that renaming a module is only allowed at its definition. This simplification reduces a lot of computations. 2. Based on the first point, our preparation no longer returns just a single local module, but instead, the entire module. This means that module renaming has become more powerful. We can not only rename a single local module but also simplify a module. For example, renaming TopLevel.Parent.Child to TopLevel.Child, or renaming some middle parts, like TopLevel.Parent.Child to TopLevel.Renamed. I personally really like this change, especially the second point, which makes module renaming much more practical. Surround the whole module when renaming happens Remove logic related to the rename function. Apply some code review suggestions Fix a bug when expanding the module Fix a merge error Apply a format module usage suggestion Update apps/remote_control/lib/lexical/remote_control/code_mod/rename.ex Co-authored-by: Steve Cohen <[email protected]> Apply the `defdelegate` suggestion Fix a bug when the descendant containing the old suffix

Enhanced the application by integrating rename functionality, increasing its editing capabilities. This includes supporting the preparation and execution of rename operations in various modules such as the lexical AST module, protocol request and response modules, remote control API, and server provider handling. Key additions entail aliasing for easier reference, handling new rename-related requests and responses, and implementing server state updates to acknowledge rename capabilities. The changes underscore our dedication to improving the tool's utility and ensuring a more dynamic and responsive user experience in code manipulation scenarios. Filter out the `:struct` type references Add some handler tests for `rename` Add doc for `local_module_name` Move `rename` from `code_intelligence` to `code_mod` Move the prepare logic to a individual module This PR is primarily copied from lexical-lsp#374, but compared to the previous implementation, we have made two changes: 1. We constrained the scope of renaming, meaning that renaming a module is only allowed at its definition. This simplification reduces a lot of computations. 2. Based on the first point, our preparation no longer returns just a single local module, but instead, the entire module. This means that module renaming has become more powerful. We can not only rename a single local module but also simplify a module. For example, renaming TopLevel.Parent.Child to TopLevel.Child, or renaming some middle parts, like TopLevel.Parent.Child to TopLevel.Renamed. I personally really like this change, especially the second point, which makes module renaming much more practical. Surround the whole module when renaming happens Remove logic related to the rename function. Apply some code review suggestions Fix a bug when expanding the module Fix a merge error Apply a format module usage suggestion Update apps/remote_control/lib/lexical/remote_control/code_mod/rename.ex Co-authored-by: Steve Cohen <[email protected]> Apply the `defdelegate` suggestion Fix a bug when the descendant containing the old suffix

Enhanced the application by integrating rename functionality, increasing its editing capabilities. This includes supporting the preparation and execution of rename operations in various modules such as the lexical AST module, protocol request and response modules, remote control API, and server provider handling. Key additions entail aliasing for easier reference, handling new rename-related requests and responses, and implementing server state updates to acknowledge rename capabilities. The changes underscore our dedication to improving the tool's utility and ensuring a more dynamic and responsive user experience in code manipulation scenarios. Filter out the `:struct` type references Add some handler tests for `rename` Add doc for `local_module_name` Move `rename` from `code_intelligence` to `code_mod` Move the prepare logic to a individual module This PR is primarily copied from #374, but compared to the previous implementation, we have made two changes: 1. We constrained the scope of renaming, meaning that renaming a module is only allowed at its definition. This simplification reduces a lot of computations. 2. Based on the first point, our preparation no longer returns just a single local module, but instead, the entire module. This means that module renaming has become more powerful. We can not only rename a single local module but also simplify a module. For example, renaming TopLevel.Parent.Child to TopLevel.Child, or renaming some middle parts, like TopLevel.Parent.Child to TopLevel.Renamed. I personally really like this change, especially the second point, which makes module renaming much more practical. Surround the whole module when renaming happens Remove logic related to the rename function. Apply some code review suggestions Fix a bug when expanding the module Fix a merge error Apply a format module usage suggestion Update apps/remote_control/lib/lexical/remote_control/code_mod/rename.ex Co-authored-by: Steve Cohen <[email protected]> Apply the `defdelegate` suggestion Fix a bug when the descendant containing the old suffix

scottming commented Sep 17, 2023

View reviewed changes

apps/remote_control/lib/lexical/remote_control/code_intelligence/entity.ex Outdated Show resolved Hide resolved

scottming changed the title ~~Rename module~~ Add Support for Renaming module Sep 17, 2023

scottming force-pushed the rename-module branch from bcd946b to 7335a95 Compare September 17, 2023 08:41

scottming requested review from zachallaun and scohen September 17, 2023 08:45

scottming force-pushed the rename-module branch from 7335a95 to eb2af3b Compare September 17, 2023 09:21

zachallaun reviewed Sep 17, 2023

View reviewed changes

apps/remote_control/test/lexical/remote_control/code_intelligence/rename_test.exs Outdated Show resolved Hide resolved

scohen reviewed Sep 17, 2023

View reviewed changes

apps/remote_control/lib/lexical/remote_control/code_intelligence/rename.ex Outdated Show resolved Hide resolved

scottming marked this pull request as draft September 19, 2023 14:15

scottming force-pushed the rename-module branch from 5868129 to 576e148 Compare October 16, 2023 02:27

scottming force-pushed the rename-module branch 2 times, most recently from 43deb94 to 2b64396 Compare December 3, 2023 09:20

scottming marked this pull request as ready for review December 3, 2023 09:20

zachallaun requested changes Dec 5, 2023

View reviewed changes

scottming force-pushed the rename-module branch 2 times, most recently from ee3b3e6 to da6b905 Compare December 9, 2023 10:25

scottming force-pushed the rename-module branch from da6b905 to 65c3550 Compare December 9, 2023 11:11

scohen reviewed Dec 11, 2023

View reviewed changes

scottming force-pushed the rename-module branch 2 times, most recently from 143d52b to c6047d3 Compare December 17, 2023 02:57

Add prefix search implementation

dce4d0d

scottming force-pushed the rename-module branch 4 times, most recently from f0586d8 to 8849f77 Compare December 31, 2023 06:44

scottming closed this Feb 16, 2024

scottming mentioned this pull request Mar 3, 2024

Add Support for Renaming module #636

Open

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Add Support for `Renaming module` #374

Add Support for `Renaming module` #374

scottming commented Sep 17, 2023 •

edited

Loading

zachallaun left a comment

zachallaun commented Sep 17, 2023

scottming commented Dec 4, 2023 •

edited

Loading

zachallaun Dec 4, 2023

scohen Dec 9, 2023

scottming Dec 9, 2023 •

edited

Loading

zachallaun Dec 5, 2023

scottming Dec 9, 2023

zachallaun Dec 5, 2023

scottming Dec 9, 2023

zachallaun Dec 5, 2023

scottming Dec 9, 2023 •

edited

Loading

scottming commented Dec 9, 2023

scohen left a comment

scohen Dec 9, 2023

scohen Dec 11, 2023

scohen Dec 11, 2023

scottming Dec 12, 2023

scohen Dec 11, 2023

scohen Dec 11, 2023

scottming Dec 17, 2023

scohen Dec 11, 2023

scottming Dec 31, 2023

scottming commented Dec 31, 2023

scottming commented Feb 10, 2024

	with {:ok, entity, range} <- resolve_module(analysis, position) do
	with {:ok, entity, range} <- Entity.resolve(analysis, position, [:module, :struct]) do

	start_supervised!(Document.Store)
	start_supervised!(Lexical.Server.Application.document_store_child_spec())

	test "succeeds when the cursor on the definition" do
	test "succeeds when the cursor is before the definition" do

Add Support for Renaming module #374

Add Support for Renaming module #374

Conversation

scottming commented Sep 17, 2023 • edited Loading

TODO

zachallaun left a comment

Choose a reason for hiding this comment

zachallaun commented Sep 17, 2023

scottming commented Dec 4, 2023 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

scottming Dec 9, 2023 • edited Loading

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

scottming Dec 9, 2023 • edited Loading

Choose a reason for hiding this comment

scottming commented Dec 9, 2023

PrepareRename and Rename in Vscode

in Neovim

scohen left a comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

Choose a reason for hiding this comment

scottming commented Dec 31, 2023

scottming commented Feb 10, 2024

Add Support for `Renaming module` #374

Add Support for `Renaming module` #374

scottming commented Sep 17, 2023 •

edited

Loading

scottming commented Dec 4, 2023 •

edited

Loading

scottming Dec 9, 2023 •

edited

Loading

scottming Dec 9, 2023 •

edited

Loading