improvements to declaration provider

Author: lukaszsamson

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

@@ -7,11 +7,14 @@ defmodule ElixirLS.LanguageServer.Providers.Declaration.Locator do
   This is effectively the reverse of the "go to implementations" provider.
   """
 
+  alias ElixirSense.Core.Binding
+  alias ElixirSense.Core.SurroundContext
   alias ElixirSense.Core.Metadata
   alias ElixirSense.Core.Normalized.Code, as: NormalizedCode
   alias ElixirSense.Core.State
   alias ElixirLS.LanguageServer.Location
   alias ElixirSense.Core.Parser
+  alias ElixirSense.Core.State.{ModFunInfo, SpecInfo}
 
   require ElixirSense.Core.Introspection, as: Introspection
 
@@ -41,33 +44,166 @@ defmodule ElixirLS.LanguageServer.Providers.Declaration.Locator do
   end
 
   @doc false
-  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)
+  def find(context, %State.Env{module: module} = env, metadata) do
+    binding_env = Binding.from_env(env, metadata, context.begin)
 
-    case env.function do
+    type = SurroundContext.to_binding(context.context, module)
+
+    case type do
       nil ->
         nil
 
-      {fun, arity} ->
-        # Get the behaviours (and possibly protocols) declared for the current module.
-        behaviours = Metadata.get_module_behaviours(metadata, env, module)
-
-        # For each behaviour, if the current function is a callback for it,
-        # try to find the callback’s declaration.
-        locations =
-          for behaviour <- behaviours,
-              Introspection.is_callback(behaviour, fun, arity, metadata),
-              location = get_callback_location(behaviour, fun, arity, metadata),
-              location != nil do
-            location
-          end
-
-        case locations do
-          [] -> nil
-          [single] -> single
-          multiple -> multiple
+      {:keyword, _} ->
+        nil
+
+      {:variable, variable, version} ->
+        var_info = Metadata.find_var(metadata, variable, version, context.begin)
+
+        if var_info == nil do
+          # find local call
+          find_function(
+            {nil, variable},
+            context,
+            env,
+            metadata,
+            binding_env
+          )
         end
+
+      {:attribute, _attribute} ->
+        nil
+
+      {module, function} ->
+        find_function(
+          {module, function},
+          context,
+          env,
+          metadata,
+          binding_env
+        )
+    end
+  end
+
+  defp find_function(
+         {{:variable, _, _} = type, function},
+         context,
+         env,
+         metadata,
+         binding_env
+       ) do
+    case Binding.expand(binding_env, type) do
+      {:atom, module} ->
+        find_function(
+          {{:atom, module}, function},
+          context,
+          env,
+          metadata,
+          binding_env
+        )
+
+      _ ->
+        nil
+    end
+  end
+
+  defp find_function(
+         {{:attribute, _} = type, function},
+         context,
+         env,
+         metadata,
+         binding_env
+       ) do
+    case Binding.expand(binding_env, type) do
+      {:atom, module} ->
+        find_function(
+          {{:atom, module}, function},
+          context,
+          env,
+          metadata,
+          binding_env
+        )
+
+      _ ->
+        nil
+    end
+  end
+
+  defp find_function(
+         {module, function},
+         context,
+         env,
+         metadata,
+         _binding_env
+       ) do
+    m = get_module(module)
+
+    case {m, function}
+         |> Introspection.actual_mod_fun(
+           env,
+           metadata.mods_funs_to_positions,
+           metadata.types,
+           context.begin,
+           true
+         ) do
+      {mod, fun, false, _} ->
+        {line, column} = context.end
+        call_arity = Metadata.get_call_arity(metadata, mod, fun, line, column) || :any
+
+        get_callback_location(env.module, fun, call_arity, metadata)
+
+      {mod, fun, true, :mod_fun} ->
+        {line, column} = context.end
+        call_arity = Metadata.get_call_arity(metadata, mod, fun, line, column) || :any
+
+        find_callback(mod, fun, call_arity, metadata, env)
+
+      _ ->
+        nil
+    end
+  end
+
+  defp get_module({:atom, module}), do: module
+  defp get_module(_), do: nil
+
+  def find_callback(mod, fun, arity, metadata, env) do
+    # Get the behaviours (and possibly protocols) declared for the current module.
+    behaviours = Metadata.get_module_behaviours(metadata, env, mod)
+
+    # For each behaviour, if the current function is a callback for it,
+    # try to find the callback’s declaration.
+    locations =
+      for behaviour <- behaviours ++ [mod],
+          Introspection.is_callback(behaviour, fun, arity, metadata),
+          location = get_callback_location(behaviour, fun, arity, metadata),
+          location != nil do
+        location
+      end
+
+    locations =
+      if locations == [] do
+        # check if function is overridable
+        # NOTE we only go over local buffer defs. There is no way to tell if a remote def has been overridden.
+        metadata.mods_funs_to_positions
+        |> Enum.filter(fn
+          {{^mod, ^fun, a}, %ModFunInfo{overridable: {true, _module_with_overridables}}}
+          when Introspection.matches_arity?(a, arity) ->
+            true
+
+          {_, _} ->
+            false
+        end)
+        |> Enum.map(fn {_, %ModFunInfo{overridable: {true, module_with_overridables}}} ->
+          # assume overridables are defined by __using__ macro
+          get_function_location(module_with_overridables, :__using__, :any, metadata)
+        end)
+      else
+        locations
+      end
+
+    case locations do
+      [] -> nil
+      [single] -> single
+      multiple -> multiple
     end
   end
 
@@ -76,7 +212,8 @@ defmodule ElixirLS.LanguageServer.Providers.Declaration.Locator do
   # to trying to locate the source code.
   defp get_callback_location(behaviour, fun, arity, metadata) do
     case Enum.find(metadata.specs, fn
-           {{^behaviour, ^fun, a}, _spec_info} ->
+           {{^behaviour, ^fun, a}, %SpecInfo{kind: kind}}
+           when kind in [:callback, :macrocallback] ->
              Introspection.matches_arity?(a, arity)
 
            _ ->
@@ -91,7 +228,34 @@ defmodule ElixirLS.LanguageServer.Providers.Declaration.Locator do
 
         %Location{
           file: nil,
-          type: :callback,
+          type: spec_info.kind,
+          line: line,
+          column: column,
+          end_line: end_line,
+          end_column: end_column
+        }
+    end
+  end
+
+  defp get_function_location(mod, fun, arity, metadata) do
+    fn_definition =
+      Location.get_function_position_using_metadata(
+        mod,
+        fun,
+        arity,
+        metadata.mods_funs_to_positions
+      )
+
+    case fn_definition do
+      nil ->
+        Location.find_mod_fun_source(mod, fun, arity)
+
+      %ModFunInfo{} = info ->
+        {{line, column}, {end_line, end_column}} = Location.info_to_range(info)
+
+        %Location{
+          file: nil,
+          type: ModFunInfo.get_category(info),
           line: line,
           column: column,
           end_line: end_line,

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

@@ -296,7 +296,7 @@ defmodule ElixirLS.LanguageServer.Providers.Definition.Locator do
     end
   end
 
-  def find_function(mod, fun, arity, metadata) do
+  defp find_function(mod, fun, arity, metadata) do
     fn_definition =
       Location.get_function_position_using_metadata(
         mod,