return hover on specs and callbacks

Author: lukaszsamson

apps/language_server/lib/language_server/providers/declaration/locator.ex

@@ -7,8 +7,6 @@ defmodule ElixirLS.LanguageServer.Providers.Declaration.Locator do
   This is effectively the reverse of the "go to implementations" provider.
   """
 
-  alias ElixirSense.Core.Behaviours
-  alias ElixirSense.Core.Binding
   alias ElixirSense.Core.Metadata
   alias ElixirSense.Core.Normalized.Code, as: NormalizedCode
   alias ElixirSense.Core.State
@@ -43,7 +41,7 @@ defmodule ElixirLS.LanguageServer.Providers.Declaration.Locator do
   end
 
   @doc false
-  def find(context, %State.Env{module: module} = env, metadata) do
+  def find(_context, %State.Env{module: module} = env, metadata) do
     # Get the binding environment as in the other providers.
     # binding_env = Binding.from_env(env, metadata, context.begin)
 

apps/language_server/lib/language_server/providers/hover.ex

@@ -92,6 +92,20 @@ defmodule ElixirLS.LanguageServer.Providers.Hover do
     end
   end
 
+  defp build_callback_link(module, callback, arity) do
+    if module != nil and ElixirSense.Core.Introspection.elixir_module?(module) do
+      url = DocLinks.hex_docs_callback_link(module, callback, arity)
+
+      if url do
+        "[View on hexdocs](#{url})\n\n"
+      else
+        ""
+      end
+    else
+      ""
+    end
+  end
+
   defp format_doc(info = %{kind: :module}) do
     mod_str = inspect(info.module)
 
@@ -177,6 +191,37 @@ defmodule ElixirLS.LanguageServer.Providers.Hover do
     """
   end
 
+  defp format_doc(info = %{kind: kind}) when kind in [:callback, :macrocallback] do
+    joined = Enum.join(info.specs, "\n")
+    formatted_spec = "```elixir\n#{joined}\n```"
+
+    mod_formatted =
+      case info.module do
+        nil -> ""
+        atom -> inspect(atom) <> "."
+      end
+
+    callback_name =
+      "#{mod_formatted}#{info.callback}(#{Enum.join(info.args, ", ")})"
+      |> format_header
+
+    """
+    ```elixir
+    #{callback_name}
+    ```
+
+    *#{kind}* #{build_callback_link(info.module, info.callback, info.arity)}
+
+    #{MarkdownUtils.get_metadata_md(info.metadata)}
+
+    ### Definition
+
+    #{formatted_spec}
+
+    #{documentation_section(info.docs) |> MarkdownUtils.transform_ex_doc_links(info.module)}
+    """
+  end
+
   defp format_doc(info = %{kind: :variable}) do
     """
     ```elixir

apps/language_server/lib/language_server/providers/hover/docs.ex

@@ -16,7 +16,7 @@ defmodule ElixirLS.LanguageServer.Providers.Hover.Docs do
   alias ElixirSense.Core.ReservedWords
   alias ElixirSense.Core.State
   alias ElixirSense.Core.SurroundContext
-  alias ElixirSense.Core.State.ModFunInfo
+  alias ElixirSense.Core.State.{ModFunInfo, SpecInfo}
   alias ElixirSense.Core.TypeInfo
   alias ElixirSense.Core.Parser
 
@@ -181,6 +181,47 @@ defmodule ElixirLS.LanguageServer.Providers.Hover.Docs do
       )
 
     case actual do
+      {_, f, false, _} ->
+        module = env.module
+        {line, column} = context.end
+        call_arity = Metadata.get_call_arity(metadata, env.module, f, line, column) || :any
+
+        metadata.specs
+        |> Enum.filter(fn
+          {{^module, ^f, a}, %SpecInfo{}} ->
+            Introspection.matches_arity?(a, call_arity)
+
+          _ ->
+            false
+        end)
+        |> Enum.map(fn {{_module, _f, arity}, spec_info = %SpecInfo{}} ->
+          case spec_info do
+            %SpecInfo{kind: :spec} ->
+              # return def docs on on spec
+              get_all_docs({module, fun, arity}, metadata, env, :mod_fun)
+
+            %SpecInfo{kind: kind} when kind in [:callback, :macrocallback] ->
+              specs =
+                spec_info.specs
+                |> Enum.reject(&String.starts_with?(&1, "@spec"))
+                |> Enum.reverse()
+
+              [
+                %{
+                  kind: kind,
+                  module: module,
+                  callback: fun,
+                  arity: arity,
+                  args: spec_info.args |> List.last(),
+                  metadata: spec_info.meta,
+                  specs: specs,
+                  docs: spec_info.doc
+                }
+              ]
+          end
+        end)
+        |> List.flatten()
+
       {mod, fun, true, kind} ->
         {line, column} = context.end
         call_arity = Metadata.get_call_arity(metadata, mod, fun, line, column) || :any

apps/language_server/test/providers/hover/docs_test.exs

@@ -531,7 +531,7 @@ defmodule ElixirLS.LanguageServer.Providers.Hover.DocsTest do
              } = Docs.docs(buffer, 5, 6)
     end
 
-    test "find definition of local macro on definition" do
+    test "retrieve documentation of local macro on definition" do
       buffer = """
       defmodule MyModule do
         defmacrop some(var), do: Macro.expand(var, __CALLER__)
@@ -547,6 +547,56 @@ defmodule ElixirLS.LanguageServer.Providers.Hover.DocsTest do
              } = Docs.docs(buffer, 2, 14)
     end
 
+    test "retrieve documentation of local macro on spec" do
+      buffer = """
+      defmodule MyModule do
+        @doc "Some macro"
+        @spec some(integer()) :: Macro.t()
+        defmacro some(var), do: Macro.expand(var, __CALLER__)
+      end
+      """
+
+      assert %{
+               docs: [
+                 %{
+                   args: ["var"],
+                   arity: 1,
+                   function: :some,
+                   module: MyModule,
+                   metadata: %{},
+                   specs: ["@spec some(integer()) :: Macro.t()"],
+                   docs: "Some macro",
+                   kind: :macro
+                 }
+               ]
+             } = Docs.docs(buffer, 3, 10)
+    end
+
+    test "retrieve documentation of local function on spec" do
+      buffer = """
+      defmodule MyModule do
+        @doc "Some fun"
+        @spec some(integer()) :: atom()
+        def some(var), do: Macro.expand(var, __CALLER__)
+      end
+      """
+
+      assert %{
+               docs: [
+                 %{
+                   args: ["var"],
+                   arity: 1,
+                   function: :some,
+                   module: MyModule,
+                   metadata: %{},
+                   specs: ["@spec some(integer()) :: atom()"],
+                   docs: "Some fun",
+                   kind: :function
+                 }
+               ]
+             } = Docs.docs(buffer, 3, 10)
+    end
+
     test "does not find definition of local macro if it's defined after the cursor" do
       buffer = """
       defmodule MyModule do
@@ -1361,6 +1411,58 @@ defmodule ElixirLS.LanguageServer.Providers.Hover.DocsTest do
     end
   end
 
+  describe "callbacks" do
+    test "retrieve documentation of local callback" do
+      buffer = """
+      defmodule MyModule do
+        @doc "Some callback"
+        @doc since: "2.3"
+        @callback some(integer()) :: atom()
+      end
+      """
+
+      assert %{
+               docs: [
+                 %{
+                   args: ["integer()"],
+                   arity: 1,
+                   module: MyModule,
+                   callback: :some,
+                   metadata: %{since: "2.3"},
+                   specs: ["@callback some(integer()) :: atom()"],
+                   docs: "Some callback",
+                   kind: :callback
+                 }
+               ]
+             } = Docs.docs(buffer, 4, 14)
+    end
+
+    test "retrieve documentation of local macrocallback" do
+      buffer = """
+      defmodule MyModule do
+        @doc "Some macrocallback"
+        @doc since: "2.3"
+        @macrocallback some(integer()) :: Macro.t()
+      end
+      """
+
+      assert %{
+               docs: [
+                 %{
+                   args: ["integer()"],
+                   arity: 1,
+                   module: MyModule,
+                   callback: :some,
+                   metadata: %{since: "2.3"},
+                   specs: ["@macrocallback some(integer()) :: Macro.t()"],
+                   docs: "Some macrocallback",
+                   kind: :macrocallback
+                 }
+               ]
+             } = Docs.docs(buffer, 4, 19)
+    end
+  end
+
   describe "types" do
     test "type with @typedoc false" do
       buffer = """

apps/language_server/test/providers/hover_test.exs

@@ -99,6 +99,28 @@ defmodule ElixirLS.LanguageServer.Providers.HoverTest do
            )
   end
 
+  test "callback hover" do
+    text = """
+    defmodule MyModule do
+      @callback some(integer()) :: atom()
+    end
+    """
+
+    {line, char} = {1, 13}
+    parser_context = ParserContextBuilder.from_string(text)
+
+    {line, char} =
+      SourceFile.lsp_position_to_elixir(parser_context.source_file.text, {line, char})
+
+    assert {:ok, %{"contents" => %{kind: "markdown", value: v}}} =
+             Hover.hover(parser_context, line, char)
+
+    assert String.starts_with?(
+             v,
+             "```elixir\nMyModule.some(integer())\n```\n\n*callback*"
+           )
+  end
+
   test "elixir type hover" do
     text = """
     defmodule MyModule do