make tests pass

Author: lukaszsamson

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

@@ -747,17 +747,15 @@ defmodule ElixirLS.LanguageServer.Providers.Completion do
   defp from_completion_item(%{type: :param_option} = suggestion, context, _options) do
     %{
       name: name,
-      origin: _origin,
-      doc: doc,
       type_spec: type_spec,
-      expanded_spec: expanded_spec,
+      origin: origin,
       subtype: subtype
     } =
       suggestion
 
     formatted_spec =
-      if expanded_spec != "" do
-        "\n\n```elixir\n#{expanded_spec}\n```\n"
+      if type_spec != "" do
+        "\n\n```elixir\n#{type_spec}\n```\n"
       else
         ""
       end
@@ -789,8 +787,8 @@ defmodule ElixirLS.LanguageServer.Providers.Completion do
 
     %__MODULE__{
       label: to_string(name),
-      detail: "#{type_spec}",
-      documentation: "#{doc}#{formatted_spec}",
+      detail: "#{origin} option",
+      documentation: formatted_spec,
       insert_text: insert_text,
       text_edit: text_edit,
       priority: 10,

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

@@ -18,9 +18,7 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.Reducers.Params do
           subtype: :keyword | :atom,
           name: String.t(),
           origin: String.t(),
-          type_spec: String.t(),
-          doc: String.t(),
-          expanded_spec: String.t()
+          type_spec: String.t()
         }
 
   @doc """
@@ -60,10 +58,8 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.Reducers.Params do
                 expanded_spec = Introspection.to_string_with_parens(type)
 
                 %{
-                  doc: "",
-                  expanded_spec: expanded_spec,
                   name: name |> Atom.to_string(),
-                  origin: inspect(mod),
+                  origin: "#{inspect(mod)}.#{fun}",
                   type: :param_option,
                   subtype: :keyword,
                   type_spec: expanded_spec
@@ -75,10 +71,8 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.Reducers.Params do
               if options_so_far == [] and cursor_at_option == true and
                    Matcher.match?(inspect(name), hint) do
                 %{
-                  doc: "",
-                  expanded_spec: "",
                   name: name |> Atom.to_string(),
-                  origin: inspect(mod),
+                  origin: "#{inspect(mod)}.#{fun}",
                   type: :param_option,
                   subtype: :atom,
                   type_spec: ""

apps/language_server/test/providers/completion/suggestions_test.exs

@@ -3734,219 +3734,163 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.SuggestionTest do
     test "options as inline list" do
       buffer = "Local.func_with_options_as_inline_list("
 
-      assert %{type_spec: "local_t()", expanded_spec: "@type local_t() :: atom()"} =
+      assert %{type_spec: "atom()"} =
                suggestion_by_name("local_o", buffer)
 
       assert %{
-               type_spec: "keyword()",
-               expanded_spec: """
-               @type keyword() :: [
-                 {atom(), any()}
-               ]\
-               """
+               type_spec: "keyword()"
              } = suggestion_by_name("builtin_o", buffer)
     end
 
     test "options vars defined in when" do
-      type_spec = "local_t()"
-      origin = "ElixirSenseExample.ModuleWithTypespecs.Local"
-      spec = "@type local_t() :: atom()"
+      type_spec = "atom()"
+      origin = "ElixirSenseExample.ModuleWithTypespecs.Local.func_with_option_var_defined_in_when"
 
       buffer = "Local.func_with_option_var_defined_in_when("
       suggestion = suggestion_by_name("local_o", buffer)
 
       assert suggestion.type_spec == type_spec
       assert suggestion.origin == origin
-      assert suggestion.expanded_spec == spec
+
+      origin = "ElixirSenseExample.ModuleWithTypespecs.Local.func_with_options_var_defined_in_when"
 
       buffer = "Local.func_with_options_var_defined_in_when("
       suggestion = suggestion_by_name("local_o", buffer)
 
       assert suggestion.type_spec == type_spec
       assert suggestion.origin == origin
-      assert suggestion.expanded_spec == spec
     end
 
     test "opaque type internal structure is not revealed" do
       buffer = "Local.func_with_options("
       suggestion = suggestion_by_name("opaque_o", buffer)
 
       assert suggestion.type_spec == "opaque_t()"
-      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local"
-      assert suggestion.expanded_spec == "@opaque opaque_t()"
-      assert suggestion.doc == "Local opaque type"
+      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local.func_with_options"
     end
 
     test "private type" do
       buffer = "Local.func_with_options("
       suggestion = suggestion_by_name("private_o", buffer)
 
-      assert suggestion.type_spec == "private_t()"
-      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local"
-      assert suggestion.expanded_spec == "@typep private_t() :: atom()"
-      assert suggestion.doc == ""
+      assert suggestion.type_spec == "atom()"
+      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local.func_with_options"
     end
 
     test "local type" do
       buffer = "Local.func_with_options("
       suggestion = suggestion_by_name("local_o", buffer)
 
-      assert suggestion.type_spec == "local_t()"
-      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local"
-      assert suggestion.expanded_spec == "@type local_t() :: atom()"
-      assert suggestion.doc == "Local type"
+      assert suggestion.type_spec == "atom()"
+      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local.func_with_options"
     end
 
     test "local type with params" do
       buffer = "Local.func_with_options("
       suggestion = suggestion_by_name("local_with_params_o", buffer)
 
-      assert suggestion.type_spec == "local_t(atom(), integer())"
-      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local"
-      assert suggestion.expanded_spec =~ "@type local_t(a, b) ::"
+      assert suggestion.type_spec == "{atom(), integer()}"
+      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local.func_with_options"
     end
 
     test "basic type" do
       buffer = "Local.func_with_options("
       suggestion = suggestion_by_name("basic_o", buffer)
 
       assert suggestion.type_spec == "pid()"
-      assert suggestion.origin == ""
-      assert suggestion.expanded_spec == ""
-      assert suggestion.doc == "A process identifier, pid, identifies a process"
+      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local.func_with_options"
     end
 
     test "basic type with params" do
       buffer = "Local.func_with_options("
       suggestion = suggestion_by_name("basic_with_params_o", buffer)
 
       assert suggestion.type_spec == "[atom(), ...]"
-      assert suggestion.origin == ""
-      assert suggestion.expanded_spec == ""
-      assert suggestion.doc == "Non-empty proper list"
+      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local.func_with_options"
     end
 
     test "built-in type" do
       buffer = "Local.func_with_options("
       suggestion = suggestion_by_name("builtin_o", buffer)
 
       assert suggestion.type_spec == "keyword()"
-      assert suggestion.origin == ""
-
-      assert suggestion.expanded_spec == """
-             @type keyword() :: [
-               {atom(), any()}
-             ]\
-             """
-
-      assert suggestion.doc == "A keyword list"
+      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local.func_with_options"
     end
 
     test "built-in type with params" do
       buffer = "Local.func_with_options("
       suggestion = suggestion_by_name("builtin_with_params_o", buffer)
 
       assert suggestion.type_spec == "keyword(term())"
-      assert suggestion.origin == ""
-      assert suggestion.expanded_spec =~ "@type keyword(t()) ::"
-      assert suggestion.doc == "A keyword list with values of type `t`"
+      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local.func_with_options"
     end
 
     test "union type" do
       buffer = "Local.func_with_options("
       suggestion = suggestion_by_name("union_o", buffer)
 
-      assert suggestion.type_spec == "union_t()"
-      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local"
-
-      assert suggestion.expanded_spec == """
-             @type union_t() ::
-               atom() | integer()\
-             """
+      assert suggestion.type_spec == "atom() | integer()"
+      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local.func_with_options"
     end
 
     test "list type" do
       buffer = "Local.func_with_options("
       suggestion = suggestion_by_name("list_o", buffer)
 
-      assert suggestion.type_spec == "list_t()"
-      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local"
-      assert suggestion.expanded_spec =~ "@type list_t() ::"
+      assert suggestion.type_spec == "[:trace | :log]"
+      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local.func_with_options"
     end
 
     test "remote type" do
       buffer = "Local.func_with_options("
       suggestion = suggestion_by_name("remote_o", buffer)
 
-      assert suggestion.type_spec == "ElixirSenseExample.ModuleWithTypespecs.Remote.remote_t()"
-      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Remote"
-      assert suggestion.expanded_spec == "@type remote_t() :: atom()"
-      assert suggestion.doc == "Remote type"
+      assert suggestion.type_spec == "atom()"
+      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local.func_with_options"
     end
 
     test "remote type with args" do
       buffer = "Local.func_with_options("
       suggestion = suggestion_by_name("remote_with_params_o", buffer)
 
       assert suggestion.type_spec ==
-               "ElixirSenseExample.ModuleWithTypespecs.Remote.remote_t(atom(), integer())"
+               "{atom(), integer()}"
 
-      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Remote"
-      assert suggestion.expanded_spec =~ "@type remote_t(a, b) ::"
-      assert suggestion.doc == "Remote type with params"
+      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local.func_with_options"
     end
 
     test "remote erlang type with doc" do
       buffer = "Local.func_with_erlang_type_options("
       suggestion = suggestion_by_name("erlang_t", buffer)
 
       assert suggestion.type_spec ==
-               ":erlang.time_unit()"
-
-      assert suggestion.origin == ":erlang"
-
-      assert suggestion.expanded_spec ==
-               "@type time_unit() ::\n  pos_integer()\n  | :second\n  | :millisecond\n  | :microsecond\n  | :nanosecond\n  | :native\n  | :perf_counter\n  | deprecated_time_unit()"
+               "pos_integer()\n| :second\n| :millisecond\n| :microsecond\n| :nanosecond\n| :native\n| :perf_counter\n| :seconds\n| :milli_seconds\n| :micro_seconds\n| :nano_seconds"
 
-      if System.otp_release() |> String.to_integer() >= 23 do
-        assert suggestion.doc =~ "Supported time unit representations"
-      end
+      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local.func_with_erlang_type_options"
     end
 
     test "remote aliased type" do
       buffer = "Local.func_with_options("
       suggestion = suggestion_by_name("remote_aliased_o", buffer)
 
-      assert suggestion.type_spec == "remote_aliased_t()"
-      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local"
-
-      assert suggestion.expanded_spec == """
-             @type remote_aliased_t() ::
-               ElixirSenseExample.ModuleWithTypespecs.Remote.remote_t()
-               | ElixirSenseExample.ModuleWithTypespecs.Remote.remote_list_t()\
-             """
-
-      assert suggestion.doc == "Remote type from aliased module"
+      assert suggestion.type_spec == "atom() | [atom()]"
+      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local.func_with_options"
     end
 
     test "remote aliased inline type" do
       buffer = "Local.func_with_options("
       suggestion = suggestion_by_name("remote_aliased_inline_o", buffer)
 
-      assert suggestion.type_spec == "ElixirSenseExample.ModuleWithTypespecs.Remote.remote_t()"
-      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Remote"
-      assert suggestion.expanded_spec == "@type remote_t() :: atom()"
-      assert suggestion.doc == "Remote type"
+      assert suggestion.type_spec == "atom()"
+      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local.func_with_options"
     end
 
     test "inline list type" do
       buffer = "Local.func_with_options("
       suggestion = suggestion_by_name("inline_list_o", buffer)
 
       assert suggestion.type_spec == "[:trace | :log]"
-      assert suggestion.origin == ""
-      assert suggestion.expanded_spec == ""
-      assert suggestion.doc == ""
+      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local.func_with_options"
     end
 
     test "non existent type" do
@@ -3956,14 +3900,12 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.SuggestionTest do
       assert suggestion.type_spec ==
                "ElixirSenseExample.ModuleWithTypespecs.Remote.non_existent()"
 
-      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Remote"
-      assert suggestion.expanded_spec == ""
-      assert suggestion.doc == ""
+      assert suggestion.origin == "ElixirSenseExample.ModuleWithTypespecs.Local.func_with_options"
     end
 
     test "named options" do
       buffer = "Local.func_with_named_options("
-      assert suggestion_by_name("local_o", buffer).type_spec == "local_t()"
+      assert suggestion_by_name("local_o", buffer).type_spec == "atom()"
     end
 
     test "options with only one option" do
@@ -3974,14 +3916,14 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.SuggestionTest do
     test "union of options" do
       buffer = "Local.func_with_union_of_options("
 
-      assert suggestion_by_name("local_o", buffer).type_spec == "local_t()"
+      assert suggestion_by_name("local_o", buffer).type_spec == "atom()"
       assert suggestion_by_name("option_1", buffer).type_spec == "atom()"
     end
 
     test "union of options inline" do
       buffer = "Local.func_with_union_of_options_inline("
 
-      assert suggestion_by_name("local_o", buffer).type_spec == "local_t()"
+      assert suggestion_by_name("local_o", buffer).type_spec == "atom()"
       assert suggestion_by_name("option_1", buffer).type_spec == "atom()"
     end
 
@@ -3990,9 +3932,7 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.SuggestionTest do
       assert suggestion_by_name("option_1", buffer).type_spec == "boolean()"
 
       suggestion = suggestion_by_name("remote_option_1", buffer)
-      assert suggestion.type_spec == "ElixirSenseExample.ModuleWithTypespecs.Remote.remote_t()"
-      assert suggestion.expanded_spec == "@type remote_t() :: atom()"
-      assert suggestion.doc == "Remote type"
+      assert suggestion.type_spec == "atom()"
     end
 
     test "atom only options" do
@@ -4030,15 +3970,7 @@ defmodule ElixirLS.LanguageServer.Providers.Completion.SuggestionTest do
     test "format type spec" do
       buffer = "Local.func_with_options("
 
-      assert suggestion_by_name("large_o", buffer).expanded_spec == """
-             @type large_t() ::
-               pid()
-               | port()
-               | (registered_name ::
-                    atom())
-               | {registered_name ::
-                    atom(), node()}\
-             """
+      assert suggestion_by_name("large_o", buffer).type_spec == "pid() | port() | (registered_name :: atom()) | {registered_name :: atom(), node()}"
     end
 
     test "params with default args" do

dep_versions.exs

@@ -1,5 +1,5 @@
 [
-  elixir_sense: "710b449732da6d515ed0bbb182c7681968a6d190",
+  elixir_sense: "46bfe270e86ef549b972d55199355137fac039af",
   dialyxir_vendored: "f8f64cfb6797c518294687e7c03ae817bacbc6ee",
   jason_v: "f1c10fa9c445cb9f300266122ef18671054b2330",
   erl2ex_vendored: "073ac6b9a44282e718b6050c7b27cedf9217a12a",

mix.lock

@@ -2,7 +2,7 @@
   "benchee": {:hex, :benchee, "1.1.0", "f3a43817209a92a1fade36ef36b86e1052627fd8934a8b937ac9ab3a76c43062", [:mix], [{:deep_merge, "~> 1.0", [hex: :deep_merge, repo: "hexpm", optional: false]}, {:statistex, "~> 1.0", [hex: :statistex, repo: "hexpm", optional: false]}], "hexpm", "7da57d545003165a012b587077f6ba90b89210fd88074ce3c60ce239eb5e6d93"},
   "deep_merge": {:hex, :deep_merge, "1.0.0", "b4aa1a0d1acac393bdf38b2291af38cb1d4a52806cf7a4906f718e1feb5ee961", [:mix], [], "hexpm", "ce708e5f094b9cd4e8f2be4f00d2f4250c4095be93f8cd6d018c753894885430"},
   "dialyxir_vendored": {:git, "https://github.com/elixir-lsp/dialyxir.git", "f8f64cfb6797c518294687e7c03ae817bacbc6ee", [ref: "f8f64cfb6797c518294687e7c03ae817bacbc6ee"]},
-  "elixir_sense": {:git, "https://github.com/elixir-lsp/elixir_sense.git", "710b449732da6d515ed0bbb182c7681968a6d190", [ref: "6c293f27ea3afc4f5913a7ed03a07db0fa15a0a2"]},
+  "elixir_sense": {:git, "https://github.com/elixir-lsp/elixir_sense.git", "46bfe270e86ef549b972d55199355137fac039af", [ref: "6c293f27ea3afc4f5913a7ed03a07db0fa15a0a2"]},
   "erl2ex_vendored": {:git, "https://github.com/elixir-lsp/erl2ex.git", "073ac6b9a44282e718b6050c7b27cedf9217a12a", [ref: "073ac6b9a44282e718b6050c7b27cedf9217a12a"]},
   "erlex_vendored": {:git, "https://github.com/elixir-lsp/erlex.git", "c0e448db27bcbb3f369861d13e3b0607ed37048d", [ref: "c0e448db27bcbb3f369861d13e3b0607ed37048d"]},
   "jason_v": {:git, "https://github.com/elixir-lsp/jason.git", "f1c10fa9c445cb9f300266122ef18671054b2330", [ref: "f1c10fa9c445cb9f300266122ef18671054b2330"]},