Find References

apps/remote_control/lib/lexical/remote_control/api.ex

@@ -61,6 +61,19 @@ defmodule Lexical.RemoteControl.Api do
     ])
   end
 
+  def references(
+        %Project{} = project,
+        %Document{} = document,
+        %Position{} = position,
+        include_definitions?
+      ) do
+    RemoteControl.call(project, CodeIntelligence.References, :references, [
+      document,
+      position,
+      include_definitions?
+    ])
+  end
+
   def modules_with_prefix(%Project{} = project, prefix)
       when is_binary(prefix) or is_atom(prefix) do
     RemoteControl.call(project, RemoteControl.Modules, :with_prefix, [prefix])

apps/remote_control/lib/lexical/remote_control/application.ex

@@ -17,7 +17,12 @@ defmodule Lexical.RemoteControl.Application do
           RemoteControl.Build,
           RemoteControl.Build.CaptureServer,
           RemoteControl.Plugin.Runner.Supervisor,
-          RemoteControl.Plugin.Runner.Coordinator
+          RemoteControl.Plugin.Runner.Coordinator,
+          {RemoteControl.Search.Store,
+           [
+             &RemoteControl.Search.Indexer.create_index/1,
+             &RemoteControl.Search.Indexer.update_index/2
+           ]}
         ]
       else
         []

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

@@ -0,0 +1,52 @@
+defmodule Lexical.RemoteControl.CodeIntelligence.References do
+  alias Lexical.Document
+  alias Lexical.Document.Location
+  alias Lexical.RemoteControl.CodeIntelligence.Entity
+  alias Lexical.RemoteControl.Search.Indexer.Entry
+  alias Lexical.RemoteControl.Search.Store
+
+  require Logger
+
+  def references(%Document{} = document, %Document.Position{} = position, include_definitions?) do
+    with {:ok, resolved, _range} <- Entity.resolve(document, position) do
+      find_references(resolved, include_definitions?)
+    end
+  end
+
+  defp find_references({:module, module}, include_definitions?) do
+    module_references(module, include_definitions?)
+  end
+
+  defp find_references({:struct, struct_module}, include_definitions?) do
+    module_references(struct_module, include_definitions?)
+  end
+
+  defp find_references(resolved, _include_definitions?) do
+    Logger.info("Not attempting to find references for unhandled type: #{inspect(resolved)}")
+    []
+  end
+
+  defp module_references(module, include_definitions?) do
+    with {:ok, references} <- Store.exact(module, type: :module, subtype: :reference) do
+      entities = maybe_fetch_module_definitions(module, include_definitions?) ++ references
+      locations = Enum.map(entities, &to_location/1)
+      {:ok, locations}
+    end
+  end
+
+  defp to_location(%Entry{} = entry) do
+    uri = Document.Path.ensure_uri(entry.path)
+    Location.new(entry.range, uri)
+  end
+
+  defp maybe_fetch_module_definitions(module, true) do
+    case Store.exact(module, type: :module, subtype: :definition) do
+      {:ok, definitions} -> definitions
+      _ -> []
+    end
+  end
+
+  defp maybe_fetch_module_definitions(_module, false) do
+    []
+  end
+end

apps/remote_control/lib/lexical/remote_control/dispatch.ex

@@ -7,10 +7,11 @@ defmodule Lexical.RemoteControl.Dispatch do
   `Lexical.RemoteControl.Dispatch.Handler` behaviour and add the module to the @handlers module attribute.
   """
   alias Lexical.RemoteControl
+  alias Lexical.RemoteControl.Dispatch.Handlers
   alias Lexical.RemoteControl.Dispatch.PubSub
   import Lexical.RemoteControl.Api.Messages
 
-  @handlers [PubSub]
+  @handlers [PubSub, Handlers.Indexing]
 
   # public API
 

apps/remote_control/lib/lexical/remote_control/search/store/state.ex

@@ -22,7 +22,8 @@ defmodule Lexical.RemoteControl.Search.Store.State do
       project: project,
       loaded?: false,
       update_index: update_index,
-      update_buffer: %{}
+      update_buffer: %{},
+      fuzzy: Fuzzy.from_entries([])
     }
   end
 

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

@@ -0,0 +1,134 @@
+defmodule Lexical.RemoteControl.CodeIntelligence.ReferencesTest do
+  alias Lexical.Document
+  alias Lexical.Document.Location
+  alias Lexical.RemoteControl
+  alias Lexical.RemoteControl.CodeIntelligence.References
+  alias Lexical.RemoteControl.Search
+
+  use ExUnit.Case, async: false
+
+  import Lexical.Test.CodeSigil
+  import Lexical.Test.CursorSupport
+  import Lexical.Test.Fixtures
+  import Lexical.Test.RangeSupport
+  import Lexical.Test.EventualAssertions
+
+  setup do
+    project = project()
+    RemoteControl.set_project(project)
+    start_supervised!(Document.Store)
+
+    start_supervised!(
+      {Search.Store,
+       [
+         project,
+         fn _ -> {:ok, []} end,
+         fn _, _ -> {:ok, [], []} end,
+         Search.Store.Backends.Ets
+       ]}
+    )
+
+    assert_eventually Search.Store.loaded?()
+    {:ok, project: project}
+  end
+
+  defp module_uri(project) do
+    project
+    |> file_path(Path.join("lib", "my_module.ex"))
+    |> Document.Path.ensure_uri()
+  end
+
+  defp project_module(project, content) do
+    uri = module_uri(project)
+
+    with :ok <- Document.Store.open(uri, content, 1) do
+      Document.Store.fetch(uri)
+    end
+  end
+
+  describe "module references" do
+    # Note: These tests aren't exhaustive, as that is covered by Search.StoreTest.
+    test "are found in an alias", %{project: project} do
+      code = ~q[
+        defmodule ReferencesInAlias do
+          alias ReferencedModule
+        end
+      ]
+
+      assert {:ok, [%Location{} = location]} = references(project, "ReferencedModule|", code)
+      assert decorate(code, location.range) =~ ~s[alias «ReferencedModule»]
+    end
+
+    test "are found in a module attribute", %{project: project} do
+      code = ~q[
+        defmodule ReferenceInAttribute do
+          @attr ReferencedModule
+        end
+      ]
+
+      assert {:ok, [%Location{} = location]} = references(project, "ReferencedModule|", code)
+      assert decorate(code, location.range) =~ ~s[@attr «ReferencedModule»]
+    end
+
+    test "are found in a variable", %{project: project} do
+      code = ~q[
+        some_module = ReferencedModule
+      ]
+
+      assert {:ok, [%Location{} = location]} = references(project, "ReferencedModule|", code)
+      assert decorate(code, location.range) =~ ~s[some_module = «ReferencedModule»]
+    end
+
+    test "are found in a function's parameters", %{project: project} do
+      code = ~q[
+        def some_fn(ReferencedModule) do
+        end
+      ]
+
+      assert {:ok, [%Location{} = location]} = references(project, "ReferencedModule|", code)
+      assert decorate(code, location.range) =~ ~s[def some_fn(«ReferencedModule») do]
+    end
+
+    test "includes struct definitions", %{project: project} do
+      code = ~q[
+        %ReferencedModule{} = something_else
+      ]
+
+      assert {:ok, [%Location{} = location]} = references(project, "ReferencedModule|", code)
+      assert decorate(code, location.range) =~ ~s[%«ReferencedModule»{} = something_else]
+    end
+
+    test "includes modules when a struct is requested", %{project: project} do
+      code = ~q[
+        ReferencedModule = something_else
+      ]
+
+      assert {:ok, [%Location{} = location]} = references(project, "%ReferencedModule|{}", code)
+      assert decorate(code, location.range) =~ ~s[«ReferencedModule» = something_else]
+    end
+
+    test "includes definitions if the parameter is true", %{project: project} do
+      code = ~q[
+        defmodule DefinedModule do
+        end
+
+        defmodule OtherModule do
+          @attr DefinedModule
+        end
+      ]
+
+      assert {:ok, [location_1, location_2]} = references(project, "DefinedModule|", code, true)
+      assert decorate(code, location_1.range) =~ ~s[defmodule «DefinedModule» do]
+      assert decorate(code, location_2.range) =~ ~s[@attr «DefinedModule»]
+    end
+  end
+
+  defp references(project, referenced_item, code, include_definitions? \\ false) do
+    with {position, referenced_item} <- pop_cursor(referenced_item, as: :document),
+         {:ok, document} <- project_module(project, code),
+         {:ok, entries} <- Search.Indexer.Source.index(document.path, code),
+         :ok <- Search.Store.replace(entries) do
+      References.references(referenced_item, position, include_definitions?)
+    end
+  end
+end

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

@@ -1,57 +1,24 @@
-# defmodule Lexical.Server.Provider.Handlers.FindReferences do
-#   alias Lexical.Build
-#   alias Lexical.Document
-#   alias Lexical.Protocol.Requests.FindReferences
-#   alias Lexical.Protocol.Responses
-#   alias Lexical.Protocol.Types.Location
-#   alias Lexical.Ranged
-#   alias Lexical.Tracer
-
-#   require Logger
-
-#   def handle(%FindReferences{} = request, _) do
-#     document = request.document
-#     pos = request.position
-#     trace = Tracer.get_trace()
-#     # elixir_ls uses 1 based columns, so add 1 here.
-#     character = pos.character + 1
-
-#     Build.with_lock(fn ->
-#       references =
-#         document
-#         |> Document.to_string()
-#         |> ElixirSense.references(pos.line, character, trace)
-#         |> Enum.reduce([], fn reference, acc ->
-#           case build_reference(reference, document) do
-#             {:ok, location} ->
-#               [location | acc]
-
-#             _ ->
-#               acc
-#           end
-#         end)
-#         |> Enum.reverse()
-
-#       response = Responses.FindReferences.new(request.id, references)
-#       Logger.info("found #{length(references)} refs")
-#       {:reply, response}
-#     end)
-#   end
-
-#   defp build_reference(%{range: _, uri: _} = elixir_sense_reference, current_document) do
-#     with {:ok, document} <- get_document(elixir_sense_reference, current_document),
-#          {:ok, elixir_range} <- Ranged.Native.from_lsp(elixir_sense_reference, document),
-#          {:ok, ls_range} <- Ranged.Lsp.from_native(elixir_range, document) do
-#       uri = Document.Path.ensure_uri(document.uri)
-#       {:ok, Location.new(uri: uri, range: ls_range)}
-#     end
-#   end
-
-#   defp get_document(%{uri: nil}, current_document) do
-#     {:ok, current_document}
-#   end
-
-#   defp get_document(%{uri: uri}, _) do
-#     Document.Store.open_temporary(uri)
-#   end
-# end
+defmodule Lexical.Server.Provider.Handlers.FindReferences do
+  alias Lexical.Protocol.Requests.FindReferences
+  alias Lexical.Protocol.Responses
+  alias Lexical.RemoteControl.Api
+  alias Lexical.Server.Provider.Env
+
+  require Logger
+
+  def handle(%FindReferences{} = request, %Env{} = env) do
+    include_declaration? = !!request.context.include_declaration
+
+    locations =
+      case Api.references(env.project, request.document, request.position, include_declaration?) do
+        {:ok, locations} ->
+          locations
+
+        _ ->
+          nil
+      end
+
+    response = Responses.FindReferences.new(request.id, locations)
+    {:reply, response}
+  end
+end

apps/server/lib/lexical/server/state.ex

@@ -240,6 +240,7 @@ defmodule Lexical.Server.State do
         definition_provider: true,
         document_formatting_provider: true,
         hover_provider: true,
+        references_provider: true,
         text_document_sync: sync_options
       )