feat: add hover language feature for modules and module function calls

README.md

@@ -13,6 +13,7 @@ Still in heavy development, currently supporting the following features:
 - Workspace Symbols
 - Document Symbols
 - Go To Definition
+- Hover
 
 ## Editor Support
 

lib/next_ls.ex

@@ -23,6 +23,7 @@ defmodule NextLS do
     TextDocumentDocumentSymbol,
     TextDocumentDefinition,
     TextDocumentFormatting,
+    TextDocumentHover,
     WorkspaceSymbol
   }
 
@@ -44,6 +45,7 @@ defmodule NextLS do
   }
 
   alias NextLS.DiagnosticCache
+  alias NextLS.ReferenceTable
   alias NextLS.Runtime
   alias NextLS.SymbolTable
   alias NextLS.Definition
@@ -57,7 +59,8 @@ defmodule NextLS do
         :dynamic_supervisor,
         :extensions,
         :extension_registry,
-        :symbol_table
+        :symbol_table,
+        :reference_table
       ])
 
     GenLSP.start_link(__MODULE__, args, opts)
@@ -72,6 +75,7 @@ defmodule NextLS do
     extensions = Keyword.get(args, :extensions, [NextLS.ElixirExtension])
     cache = Keyword.fetch!(args, :cache)
     symbol_table = Keyword.fetch!(args, :symbol_table)
+    reference_table = Keyword.fetch!(args, :reference_table)
     {:ok, logger} = DynamicSupervisor.start_child(dynamic_supervisor, {NextLS.Logger, lsp: lsp})
 
     {:ok,
@@ -82,6 +86,7 @@ defmodule NextLS do
        cache: cache,
        logger: logger,
        symbol_table: symbol_table,
+       reference_table: reference_table,
        task_supervisor: task_supervisor,
        runtime_task_supervisor: runtime_task_supervisor,
        dynamic_supervisor: dynamic_supervisor,
@@ -105,7 +110,8 @@ defmodule NextLS do
          document_formatting_provider: true,
          workspace_symbol_provider: true,
          document_symbol_provider: true,
-         definition_provider: true
+         definition_provider: true,
+         hover_provider: true
        },
        server_info: %{name: "NextLS"}
      }, assign(lsp, root_uri: root_uri)}
@@ -117,7 +123,7 @@ defmodule NextLS do
              URI.parse(uri).path,
              {position.line + 1, position.character + 1},
              :symbol_table,
-             :reference_table
+             lsp.assigns.reference_table
            ) do
         nil ->
           nil
@@ -159,6 +165,19 @@ defmodule NextLS do
     {:reply, symbols, lsp}
   end
 
+  def handle_request(%TextDocumentHover{params: %{text_document: %{uri: uri}, position: position}}, lsp) do
+    hover =
+      try do
+        NextLS.Hover.fetch(lsp, uri, position)
+      rescue
+        e ->
+          GenLSP.error(lsp, Exception.format_banner(:error, e, __STACKTRACE__))
+          nil
+      end
+
+    {:reply, hover, lsp}
+  end
+
   def handle_request(%WorkspaceSymbol{params: %{query: query}}, lsp) do
     filter = fn sym ->
       if query == "" do
@@ -237,6 +256,7 @@ defmodule NextLS do
 
   def handle_request(%Shutdown{}, lsp) do
     SymbolTable.close(lsp.assigns.symbol_table)
+    ReferenceTable.close(lsp.assigns.reference_table)
 
     {:reply, nil, assign(lsp, exit_code: 0)}
   end
@@ -389,7 +409,7 @@ defmodule NextLS do
   end
 
   def handle_info({{:tracer, :reference}, payload}, lsp) do
-    SymbolTable.put_reference(lsp.assigns.symbol_table, payload)
+    ReferenceTable.put_reference(lsp.assigns.reference_table, payload)
     {:noreply, lsp}
   end
 

lib/next_ls/definition.ex

@@ -1,22 +1,8 @@
 defmodule NextLS.Definition do
-  def fetch(file, {line, col}, dets_symbol_table, dets_ref_table) do
-    ref =
-      :dets.select(
-        dets_ref_table,
-        [
-          {{{:"$1", {{:"$2", :"$3"}, {:"$4", :"$5"}}}, :"$6"},
-           [
-             {:andalso,
-              {:andalso, {:andalso, {:andalso, {:==, :"$1", file}, {:"=<", :"$2", line}}, {:"=<", :"$3", col}},
-               {:"=<", line, :"$4"}}, {:"=<", col, :"$5"}}
-           ], [:"$6"]}
-        ]
-      )
+  alias NextLS.ReferenceTable
 
-    # :dets.traverse(dets_symbol_table, fn x -> {:continue, x} end) |> dbg
-    # :dets.traverse(dets_ref_table, fn x -> {:continue, x} end) |> dbg
-
-    # dbg(ref)
+  def fetch(file, position, dets_symbol_table, dets_ref_table) do
+    ref = ReferenceTable.reference(dets_ref_table, file, position)
 
     query =
       case ref do

lib/next_ls/hover.ex

@@ -0,0 +1,207 @@
+defmodule NextLS.Hover do
+  alias GenLSP.Structures.{
+    Hover,
+    MarkupContent,
+    Position,
+    Range
+  }
+
+  alias NextLS.ReferenceTable
+  alias NextLS.Runtime
+
+  @spec fetch(lsp :: GenLSP.LSP.t(), uri :: String.t(), position :: Position.t()) :: Hover.t() | nil
+  def fetch(lsp, uri, position) do
+    position = {position.line + 1, position.character + 1}
+    document = Enum.join(lsp.assigns.documents[uri], "\n")
+
+    with {module, function, range} <- find_reference(lsp, document, uri, position),
+         docs when is_binary(docs) <- fetch_docs(lsp, document, module, function) do
+      %Hover{
+        contents: %MarkupContent{
+          kind: "markdown",
+          value: docs
+        },
+        range: range
+      }
+    end
+  end
+
+  defp find_reference(lsp, document, uri, position) do
+    surround_context = Code.Fragment.surround_context(document, position)
+
+    if surround_context == :none do
+      nil
+    else
+      case ReferenceTable.reference(lsp.assigns.reference_table, URI.parse(uri).path, position) do
+        [%{type: :function, module: module, identifier: function} | _] ->
+          {module, function, build_range(surround_context)}
+
+        [%{type: :alias, module: module} | _] ->
+          {module, nil, build_range(surround_context)}
+
+        _other ->
+          find_in_context(surround_context)
+      end
+    end
+  end
+
+  defp find_in_context(%{context: {:alias, module}} = context) do
+    {to_module(module), nil, build_range(context)}
+  end
+
+  defp find_in_context(%{context: {:unquoted_atom, erlang_module}} = context) do
+    {to_atom(erlang_module), nil, build_range(context)}
+  end
+
+  defp find_in_context(_context) do
+    nil
+  end
+
+  defp fetch_docs(lsp, document, module, nil) do
+    with {:ok, {_, _, _, _, docs, _, _} = docs_v1} <- request_docs(lsp, document, module) do
+      print_doc(module, nil, nil, docs, docs_v1)
+    end
+  end
+
+  defp fetch_docs(lsp, document, module, function) do
+    with {:ok, {_, _, _, _, _, _, functions_docs} = docs_v1} <- request_docs(lsp, document, module),
+         {_, _, [spec], function_docs, _} <- find_function_docs(functions_docs, function) do
+      print_doc(module, function, spec, function_docs, docs_v1)
+    end
+  end
+
+  defp request_docs(lsp, document, module, attempt \\ 1) do
+    case send_fetch_docs_request(lsp, module) do
+      {:error, :not_ready} ->
+        nil
+
+      {:ok, {:error, :module_not_found}} ->
+        if attempt < 2 do
+          aliased_module = find_aliased_module(document, module)
+
+          if aliased_module do
+            request_docs(lsp, document, from_quoted_module_to_module(aliased_module), attempt + 1)
+          end
+        end
+
+      {:ok, {:error, :chunk_not_found}} ->
+        nil
+
+      other ->
+        other
+    end
+  end
+
+  defp find_aliased_module(document, module) do
+    module = to_quoted_module(module)
+
+    ast =
+      Code.string_to_quoted(document,
+        unescape: false,
+        token_metadata: true,
+        columns: true
+      )
+
+    {_ast, aliased_module} =
+      Macro.prewalk(ast, nil, fn
+        # alias A, as: B
+        {:alias, _, [{:__aliases__, _, aliased_module}, [as: {:__aliases__, _, ^module}]]} = expr, _ ->
+          {expr, aliased_module}
+
+        # alias A.{B, C}
+        {:alias, _, [{{:., _, [{:__aliases__, _, namespace}, :{}]}, _, aliases}]} = expr, acc ->
+          aliases = Enum.map(aliases, fn {:__aliases__, _, md} -> md end)
+
+          if module in aliases do
+            {expr, namespace ++ module}
+          else
+            {expr, acc}
+          end
+
+        # alias A.B.C
+        {:alias, _, [{:__aliases__, _, aliased_module}]} = expr, acc ->
+          offset = length(aliased_module) - length(module)
+
+          if Enum.slice(aliased_module, offset..-1) == module do
+            {expr, aliased_module}
+          else
+            {expr, acc}
+          end
+
+        expr, acc ->
+          {expr, acc}
+      end)
+
+    aliased_module
+  end
+
+  defp send_fetch_docs_request(lsp, module) do
+    Runtime.call(lsp.assigns.runtime, {Code, :fetch_docs, [module]})
+  end
+
+  defp build_range(%{begin: {line, start}, end: {_, finish}}) do
+    %Range{
+      start: %Position{line: line - 1, character: start - 1},
+      end: %Position{line: line - 1, character: finish - 1}
+    }
+  end
+
+  defp find_function_docs(docs, function) do
+    Enum.find(docs, fn
+      {{type, ^function, _}, _, _, _, _} when type in [:function, :macro] -> true
+      _ -> false
+    end)
+  end
+
+  defp print_doc(_module, _function, _spec, :none, _docs_v1) do
+    nil
+  end
+
+  defp print_doc(_module, _function, _spec, :hidden, _docs_v1) do
+    nil
+  end
+
+  defp print_doc(_module, nil, _spec, doc, {_, _, _, "text/markdown", _, _, _}) do
+    doc["en"]
+  end
+
+  defp print_doc(_module, _function, spec, doc, {_, _, _, "text/markdown", _, _, _}) do
+    print_function_spec(spec) <> doc["en"]
+  end
+
+  defp print_doc(module, nil, _spec, _doc, {_, _, :erlang, "application/erlang+html", _, _, _} = docs_v1) do
+    :shell_docs.render(module, docs_v1, %{ansi: false}) |> Enum.join()
+  end
+
+  defp print_doc(module, function, spec, _doc, {_, _, :erlang, "application/erlang+html", _, _, _} = docs_v1) do
+    print_function_spec(spec) <> (:shell_docs.render(module, function, docs_v1, %{ansi: false}) |> Enum.join())
+  end
+
+  defp print_function_spec(spec) do
+    "### " <> spec <> "\n\n"
+  end
+
+  defp from_quoted_module_to_module(quoted_module) do
+    quoted_module
+    |> Enum.map(&Atom.to_string/1)
+    |> Enum.join(".")
+    |> to_charlist()
+    |> to_module()
+  end
+
+  defp to_module(charlist) when is_list(charlist) do
+    String.to_atom("Elixir." <> to_string(charlist))
+  end
+
+  defp to_atom(charlist) when is_list(charlist) do
+    charlist |> to_string() |> String.to_atom()
+  end
+
+  defp to_quoted_module(module) when is_atom(module) do
+    module
+    |> Atom.to_string()
+    |> String.replace("Elixir.", "")
+    |> String.split(".")
+    |> Enum.map(&String.to_atom/1)
+  end
+end

lib/next_ls/lsp_supervisor.ex

@@ -32,17 +32,21 @@ defmodule NextLS.LSPSupervisor do
             raise "Unknown option"
         end
 
+      path = Path.expand(".elixir-tools")
+
       children = [
         {DynamicSupervisor, name: NextLS.DynamicSupervisor},
         {Task.Supervisor, name: NextLS.TaskSupervisor},
         {Task.Supervisor, name: :runtime_task_supervisor},
         {GenLSP.Buffer, buffer_opts},
         {NextLS.DiagnosticCache, name: :diagnostic_cache},
-        {NextLS.SymbolTable, name: :symbol_table, path: Path.expand(".elixir-tools")},
+        {NextLS.SymbolTable, name: :symbol_table, path: path},
+        {NextLS.ReferenceTable, name: :reference_table, path: path},
         {Registry, name: NextLS.ExtensionRegistry, keys: :duplicate},
         {NextLS,
          cache: :diagnostic_cache,
          symbol_table: :symbol_table,
+         reference_table: :reference_table,
          task_supervisor: NextLS.TaskSupervisor,
          runtime_task_supervisor: :runtime_task_supervisor,
          dynamic_supervisor: NextLS.DynamicSupervisor,