provide definition when cursor is on spec or callback

Author: lukaszsamson

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

@@ -13,15 +13,15 @@ defmodule ElixirLS.LanguageServer.Providers.Definition.Locator do
   """
 
   alias ElixirSense.Core.Binding
-  alias ElixirSense.Core.Introspection
+  require ElixirSense.Core.Introspection, as: Introspection
   alias ElixirSense.Core.Metadata
   alias ElixirSense.Core.State
   alias ElixirSense.Core.State.ModFunInfo
   alias ElixirSense.Core.Source
   alias ElixirSense.Core.SurroundContext
   alias ElixirLS.LanguageServer.Location
   alias ElixirSense.Core.Parser
-  alias ElixirSense.Core.State.{ModFunInfo, TypeInfo}
+  alias ElixirSense.Core.State.{ModFunInfo, TypeInfo, SpecInfo}
 
   alias ElixirLS.LanguageServer.Plugins.Phoenix.Scope
   alias ElixirSense.Core.Normalized.Code, as: NormalizedCode
@@ -240,8 +240,29 @@ defmodule ElixirLS.LanguageServer.Providers.Definition.Locator do
            context.begin,
            true
          ) do
-      {_, _, false, _} ->
-        nil
+      {_, f, false, _} ->
+        module = env.module
+        {line, column} = context.end
+        call_arity = Metadata.get_call_arity(metadata, env.module, f, line, column) || :any
+
+        Enum.find_value(metadata.specs, fn
+          {{^module, ^f, a}, spec_info = %SpecInfo{}} ->
+            if Introspection.matches_arity?(a, call_arity) do
+              {{line, column}, {end_line, end_column}} = Location.info_to_range(spec_info)
+
+              %Location{
+                file: nil,
+                type: :spec,
+                line: line,
+                column: column,
+                end_line: end_line,
+                end_column: end_column
+              }
+            end
+
+          _ ->
+            nil
+        end)
 
       {mod, fun, true, :mod_fun} ->
         {line, column} = context.end

apps/language_server/test/providers/definition/locator_test.exs

@@ -1343,6 +1343,24 @@ defmodule ElixirLS.LanguageServer.Providers.Definition.LocatorTest do
            }
   end
 
+  test "find definition of local functions on definition" do
+    buffer = """
+    defmodule MyModule do
+      def my_fun(abc), do: Asd.ASd
+      #    ^
+    end
+    """
+
+    assert Locator.definition(buffer, 2, 8) == %Location{
+             type: :function,
+             file: nil,
+             line: 2,
+             column: 3,
+             end_line: 2,
+             end_column: 31
+           }
+  end
+
   test "find definition of local functions with default args" do
     buffer = """
     defmodule MyModule do
@@ -1877,6 +1895,80 @@ defmodule ElixirLS.LanguageServer.Providers.Definition.LocatorTest do
              Locator.definition(buffer, 5, 28)
   end
 
+  test "find definition of local type on definition" do
+    buffer = """
+    defmodule MyModule do
+      @type my_fun(abc) :: :ok
+      #      ^
+    end
+    """
+
+    assert Locator.definition(buffer, 2, 10) == %Location{
+             type: :typespec,
+             file: nil,
+             line: 2,
+             column: 3,
+             end_line: 2,
+             end_column: 27
+           }
+  end
+
+  test "find definition of local spec on definition" do
+    buffer = """
+    defmodule MyModule do
+      @spec my_fun(abc()) :: :ok
+      #      ^
+      def my_fun(abc), do: :ok
+    end
+    """
+
+    assert Locator.definition(buffer, 2, 10) == %Location{
+             type: :spec,
+             file: nil,
+             line: 2,
+             column: 3,
+             end_line: 2,
+             end_column: 29
+           }
+  end
+
+  test "find definition of local spec with guard on definition" do
+    buffer = """
+    defmodule MyModule do
+      @spec my_fun(abc) :: :ok when abc: atom()
+      #      ^
+      def my_fun(abc), do: :ok
+    end
+    """
+
+    assert Locator.definition(buffer, 2, 10) == %Location{
+             type: :spec,
+             file: nil,
+             line: 2,
+             column: 3,
+             end_line: 2,
+             end_column: 44
+           }
+  end
+
+  test "find definition of local callback on definition" do
+    buffer = """
+    defmodule MyModule do
+      @callback my_fun(abc) :: :ok
+      #          ^
+    end
+    """
+
+    assert Locator.definition(buffer, 2, 14) == %Location{
+             type: :spec,
+             file: nil,
+             line: 2,
+             column: 3,
+             end_line: 2,
+             end_column: 31
+           }
+  end
+
   test "find metadata type for the correct arity - on type definition" do
     buffer = """
     defmodule MyModule do