adopt actual_mod_fun api

correctly do alias expansion in buffer call references - previously call alias was expanded with wrong env
do not expand aliases twice in definition provider

Author: lukaszsamson

apps/elixir_ls_utils/lib/completion_engine.ex

@@ -514,27 +514,30 @@ defmodule ElixirLS.Utils.CompletionEngine do
   end
 
   # do not suggest attributes outside of a module
-  defp expand_attribute(_, %State.Env{scope: scope}, %Metadata{} = _metadata)
-       when scope in [Elixir, nil],
+  defp expand_attribute(_, %State.Env{module: module}, %Metadata{} = _metadata)
+       when module == nil,
        do: no()
 
   defp expand_attribute(
          hint,
-         %State.Env{attributes: attributes, scope: scope},
+         %State.Env{attributes: attributes} = env,
          %Metadata{} = _metadata
        ) do
     attribute_names =
       attributes
       |> Enum.map(fn %State.AttributeInfo{name: name} -> name end)
 
     attribute_names =
-      case scope do
-        {_fun, _arity} ->
+      case env do
+        %State.Env{function: {_fun, _arity}} ->
           attribute_names
 
-        module when not is_nil(module) ->
+        %State.Env{module: module} when not is_nil(module) ->
           # include module attributes in module scope
           attribute_names ++ BuiltinAttributes.all()
+
+        _ ->
+          []
       end
 
     for(

apps/elixir_ls_utils/test/complete_test.exs

@@ -1104,7 +1104,8 @@ defmodule ElixirLS.Utils.CompletionEngineTest do
           name: :nothing
         }
       ],
-      scope: {:some, 0}
+      module: My,
+      function: {:some, 0}
     }
 
     assert expand(~c"@numb", env) == [%{type: :attribute, name: "@number", summary: nil}]
@@ -1126,17 +1127,17 @@ defmodule ElixirLS.Utils.CompletionEngineTest do
   test "builtin attribute name completion" do
     env_function = %Env{
       attributes: [],
-      scope: {:some, 0}
+      module: Some.Module,
+      function: {:some, 0}
     }
 
     env_module = %Env{
       attributes: [],
-      scope: Some.Module
+      module: Some.Module
     }
 
     env_outside_module = %Env{
-      attributes: [],
-      scope: Elixir
+      attributes: []
     }
 
     assert expand(~c"@befo", env_function) == []
@@ -1567,7 +1568,7 @@ defmodule ElixirLS.Utils.CompletionEngineTest do
                      type: {:atom, Date}
                    }
                  ],
-                 scope: MyMod
+                 module: MyMod
                })
 
       assert [%{name: "Range"}] =
@@ -1578,7 +1579,7 @@ defmodule ElixirLS.Utils.CompletionEngineTest do
                      type: {:atom, Date}
                    }
                  ],
-                 scope: MyMod
+                 module: MyMod
                })
     end
   end

apps/language_server/lib/language_server/providers/completion.ex

@@ -11,6 +11,7 @@ defmodule ElixirLS.LanguageServer.Providers.Completion do
   alias ElixirLS.LanguageServer.{SourceFile, Parser}
   import ElixirLS.LanguageServer.Protocol, only: [range: 4]
   alias ElixirLS.Utils.Matcher
+  alias ElixirSense.Core.State
   alias ElixirSense.Core.Normalized.Code, as: NormalizedCode
   alias ElixirLS.LanguageServer.MarkdownUtils
   require Logger
@@ -144,11 +145,11 @@ defmodule ElixirLS.LanguageServer.Providers.Completion do
     env = ElixirSense.Core.Metadata.get_env(metadata, {line, character})
 
     scope =
-      case env.scope do
-        scope when scope in [Elixir, nil] -> :file
-        module when is_atom(module) -> :module
-        {_, _} -> :function
-        {:typespec, _, _} -> :typespec
+      case env do
+        %State.Env{module: nil} -> :file
+        %State.Env{function: {_, _}} -> :function
+        %State.Env{typespec: {_, _}} -> :typespec
+        %State.Env{} -> :module
       end
 
     def_before =

apps/language_server/lib/language_server/providers/completion/reducers/callbacks.ex

@@ -27,10 +27,17 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.Reducers.Callbacks do
   @doc """
   A reducer that adds suggestions of callbacks.
   """
-  def add_callbacks(hint, env, buffer_metadata, context, acc) do
+  def add_callbacks(
+        hint,
+        env = %State.Env{module: module, typespec: nil},
+        buffer_metadata,
+        context,
+        acc
+      )
+      when module != nil do
     text_before = context.text_before
 
-    %State.Env{protocol: protocol, behaviours: behaviours, scope: scope} = env
+    %State.Env{protocol: protocol, behaviours: behaviours} = env
 
     list =
       Enum.flat_map(behaviours, fn
@@ -138,14 +145,18 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.Reducers.Callbacks do
       Regex.match?(~r/\s(def|defmacro)\s+([_\p{Ll}\p{Lo}][\p{L}\p{N}_]*[?!]?)?$/u, text_before) ->
         {:halt, %{acc | result: list}}
 
-      match?({_f, _a}, scope) ->
+      env.function != nil ->
         {:cont, acc}
 
       true ->
         {:cont, %{acc | result: acc.result ++ list}}
     end
   end
 
+  def add_callbacks(_hint, _env, _buffer_metadata, _context, acc) do
+    {:cont, acc}
+  end
+
   defp def_prefix?(hint, spec) do
     if String.starts_with?(spec, "@macrocallback") do
       String.starts_with?("defmacro", hint)

apps/language_server/lib/language_server/providers/completion/reducers/overridable.ex

@@ -14,10 +14,15 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.Reducers.Overridable do
   @doc """
   A reducer that adds suggestions of overridable functions.
   """
-  def add_overridable(_hint, %State.Env{scope: {_f, _a}}, _metadata, _cursor_context, acc),
-    do: {:cont, acc}
 
-  def add_overridable(hint, env, metadata, _cursor_context, acc) do
+  def add_overridable(
+        hint,
+        env = %State.Env{typespec: nil, module: module},
+        metadata,
+        _cursor_context,
+        acc
+      )
+      when not is_nil(module) do
     %State.Env{protocol: protocol, behaviours: behaviours, module: module} = env
 
     # overridable behaviour callbacks are returned by Reducers.Callbacks
@@ -80,6 +85,9 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.Reducers.Overridable do
     {:cont, %{acc | result: acc.result ++ Enum.sort(list)}}
   end
 
+  def add_overridable(_hint, %State.Env{}, _metadata, _cursor_context, acc),
+    do: {:cont, acc}
+
   defp def_prefix?(hint, type) when type in [:defmacro, :defmacrop] do
     String.starts_with?("defmacro", hint)
   end

apps/language_server/lib/language_server/providers/completion/reducers/params.ex

@@ -11,7 +11,6 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.Reducers.Params do
   alias ElixirSense.Core.Introspection
   alias ElixirSense.Core.Metadata
   alias ElixirSense.Core.Source
-  alias ElixirSense.Core.State
   alias ElixirSense.Core.TypeInfo
   alias ElixirLS.Utils.Matcher
 
@@ -30,13 +29,6 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.Reducers.Params do
   def add_options(hint, env, buffer_metadata, cursor_context, acc) do
     prefix = cursor_context.text_before
 
-    %State.Env{
-      requires: requires,
-      aliases: aliases,
-      module: module,
-      scope: scope
-    } = env
-
     binding_env = Binding.from_env(env, buffer_metadata)
 
     %Metadata{mods_funs_to_positions: mods_funs, types: metadata_types} = buffer_metadata
@@ -50,15 +42,11 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.Reducers.Params do
          {mod, fun, true, :mod_fun} <-
            Introspection.actual_mod_fun(
              {mod, fun},
-             env.functions,
-             env.macros,
-             requires,
-             if(elixir_prefix, do: [], else: aliases),
-             module,
-             scope,
+             env,
              mods_funs,
              metadata_types,
-             {1, 1}
+             {1, 1},
+             not elixir_prefix
            ) do
       list =
         if Code.ensure_loaded?(mod) do

apps/language_server/lib/language_server/providers/completion/reducers/protocol.ex

@@ -26,7 +26,10 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.Reducers.Protocol do
   @doc """
   A reducer that adds suggestions of protocol functions.
   """
-  def add_functions(_hint, %State.Env{scope: {_f, _a}}, _metadata, _cursor_context, acc),
+  def add_functions(_hint, %State.Env{typespec: {_f, _a}}, _metadata, _cursor_context, acc),
+    do: {:cont, acc}
+
+  def add_functions(_hint, %State.Env{module: nil}, _metadata, _cursor_context, acc),
     do: {:cont, acc}
 
   def add_functions(_hint, %State.Env{protocol: nil}, _metadata, _cursor_context, acc),

apps/language_server/lib/language_server/providers/completion/reducers/returns.ex

@@ -23,7 +23,7 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.Reducers.Returns do
   """
   def add_returns(
         "" = _hint,
-        %State.Env{scope: {fun, arity}} = env,
+        %State.Env{function: {fun, arity}} = env,
         buffer_metadata,
         _context,
         acc

apps/language_server/lib/language_server/providers/completion/reducers/type_specs.ex

@@ -33,11 +33,10 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.Reducers.TypeSpecs do
 
   # We only list type specs when inside typespec scope
   def add_types(hint, env, file_metadata, %{at_module_body?: _}, acc) do
-    if match?({:typespec, _, _}, env.scope) do
+    if match?({_, _}, env.typespec) do
       %State.Env{
         aliases: aliases,
-        module: module,
-        scope: scope
+        module: module
       } = env
 
       %Metadata{mods_funs_to_positions: mods_funs, types: metadata_types} = file_metadata
@@ -52,9 +51,7 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.Reducers.TypeSpecs do
       list =
         find_typespecs_for_mod_and_hint(
           {mod, hint},
-          aliases,
-          module,
-          scope,
+          env,
           mods_funs,
           metadata_types
         )
@@ -71,6 +68,7 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.Reducers.TypeSpecs do
   end
 
   defp expand({{kind, _} = type, hint}, env, aliases) when kind in [:attribute, :variable] do
+    # TODO Binding should return expanded aliases
     case Binding.expand(env, type) do
       {:atom, module} -> {Introspection.expand_alias(module, aliases), hint}
       _ -> {nil, ""}
@@ -83,18 +81,17 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.Reducers.TypeSpecs do
 
   defp find_typespecs_for_mod_and_hint(
          {mod, hint},
-         aliases,
-         module,
-         scope,
+         env,
          mods_funs,
          metadata_types
        ) do
-    case Introspection.actual_module(mod, aliases, module, scope, mods_funs) do
+    # alias already expanded by Source.split_module_and_hint
+    case Introspection.actual_module(mod, env, mods_funs, false) do
       {actual_mod, true} ->
-        find_module_types(actual_mod, {mod, hint}, metadata_types, module)
+        find_module_types(actual_mod, {mod, hint}, metadata_types, env.module)
 
       {nil, false} ->
-        find_module_types(module, {mod, hint}, metadata_types, module)
+        find_module_types(env.module, {mod, hint}, metadata_types, env.module)
 
       {_, false} ->
         []

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

@@ -154,7 +154,7 @@ defmodule ElixirLS.LanguageServer.Providers.Definition.Locator do
     case Binding.expand(binding_env, type) do
       {:atom, module} ->
         do_find_function_or_module(
-          {{:atom, Introspection.expand_alias(module, env.aliases)}, function},
+          {{:atom, module}, function},
           context,
           env,
           metadata,
@@ -170,7 +170,7 @@ defmodule ElixirLS.LanguageServer.Providers.Definition.Locator do
   defp do_find_function_or_module(
          {nil, :super},
          context,
-         %State.Env{scope: {function, arity}, module: module} = env,
+         %State.Env{function: {function, arity}, module: module} = env,
          metadata,
          binding_env,
          visited
@@ -200,26 +200,15 @@ defmodule ElixirLS.LanguageServer.Providers.Definition.Locator do
          _binding_env,
          _visited
        ) do
-    %State.Env{
-      module: current_module,
-      requires: requires,
-      aliases: aliases,
-      scope: scope
-    } = env
-
     m = get_module(module, context, env, metadata)
 
     case {m, function}
          |> Introspection.actual_mod_fun(
-           env.functions,
-           env.macros,
-           requires,
-           aliases,
-           current_module,
-           scope,
+           env,
            metadata.mods_funs_to_positions,
            metadata.types,
-           context.begin
+           context.begin,
+           true
          ) do
       {_, _, false, _} ->
         nil

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

@@ -181,15 +181,11 @@ defmodule ElixirLS.LanguageServer.Providers.Hover.Docs do
       {Binding.expand(binding_env, mod), fun}
       |> expand(env.aliases)
       |> Introspection.actual_mod_fun(
-        env.functions,
-        env.macros,
-        env.requires,
-        env.aliases,
-        env.module,
-        env.scope,
+        env,
         metadata.mods_funs_to_positions,
         metadata.types,
-        context.begin
+        context.begin,
+        false
       )
 
     case actual do