Always return Completion.List with is_incomplete: true

apps/remote_control/lib/lexical/remote_control/completion/candidate.ex

@@ -237,7 +237,7 @@ defmodule Lexical.RemoteControl.Completion.Candidate do
   end
 
   def from_elixir_sense(elixir_sense_map) do
-    Logger.warning("Unhandled compleetion suggestion: #{inspect(elixir_sense_map)}")
+    Logger.warning("Unhandled completion suggestion: #{inspect(elixir_sense_map)}")
     nil
   end
 end

apps/server/lib/lexical/server/code_intelligence/completion.ex

@@ -27,9 +27,8 @@ defmodule Lexical.Server.CodeIntelligence.Completion do
     [".", "@", "&", "%", "^", ":", "!", "-", "~"]
   end
 
-  @spec complete(Project.t(), Document.t(), Position.t(), Completion.Context.t()) :: [
-          Completion.Item
-        ]
+  @spec complete(Project.t(), Document.t(), Position.t(), Completion.Context.t()) ::
+          Completion.List.t()
   def complete(
         %Project{} = project,
         %Document{} = document,
@@ -40,11 +39,11 @@ defmodule Lexical.Server.CodeIntelligence.Completion do
       {:ok, env} ->
         completions = completions(project, env, context)
         Logger.warning("Emitting completions: #{inspect(completions)}")
-        completions
+        completion_list(completions)
 
       {:error, _} = error ->
         Logger.error("Failed to build completion env #{inspect(error)}")
-        empty_completion_list()
+        completion_list()
     end
   end
 
@@ -53,17 +52,17 @@ defmodule Lexical.Server.CodeIntelligence.Completion do
 
     cond do
       prefix_tokens == [] ->
-        empty_completion_list()
+        []
 
       match?([{:operator, :do, _}], prefix_tokens) and Env.empty?(env.suffix) ->
-        do_end_snippet = "do\n$0\nend"
+        do_end_snippet = "do\n  $0\nend"
 
         env
         |> Builder.snippet(do_end_snippet, label: "do/end block")
         |> List.wrap()
 
       Enum.empty?(prefix_tokens) or not context_will_give_meaningful_completions?(env) ->
-        Completion.List.new(items: [], is_incomplete: true)
+        []
 
       Env.in_context?(env, :struct_arguments) and not Env.in_context?(env, :struct_field_value) and
           not prefix_is_trigger?(env) ->
@@ -230,7 +229,7 @@ defmodule Lexical.Server.CodeIntelligence.Completion do
     true
   end
 
-  defp empty_completion_list do
-    Completion.List.new(items: [], is_incomplete: true)
+  defp completion_list(items \\ []) do
+    Completion.List.new(items: items, is_incomplete: true)
   end
 end

apps/server/test/lexical/server/code_intelligence/completion/translations/macro_test.exs

@@ -6,7 +6,7 @@ defmodule Lexical.Server.CodeIntelligence.Completion.Translations.MacroTest do
   describe "Kernel* macros" do
     test "do/end only has a single completion", %{project: project} do
       assert [completion] = complete(project, "def my_thing do|")
-      assert completion.insert_text == "do\n$0\nend"
+      assert completion.insert_text == "do\n  $0\nend"
       assert completion.label == "do/end block"
     end
 

apps/server/test/lexical/server/code_intelligence/completion_test.exs

@@ -53,22 +53,22 @@ defmodule Lexical.Server.CodeIntelligence.CompletionTest do
     end
 
     test "ignores erlang modules", %{project: project} do
-      assert %Completion.List{is_incomplete: true, items: []} = complete(project, ":e|")
+      assert %Completion.List{is_incomplete: true, items: []} =
+               complete(project, ":e|", as_list: false)
     end
   end
 
   describe "ignoring things" do
     test "return empty items and mark is_incomplete when single character contexts", %{
       project: project
     } do
-      assert complete(project, "def my_thing() d|") == %Completion.List{
-               is_incomplete: true,
-               items: []
-             }
+      assert %Completion.List{is_incomplete: true, items: []} =
+               complete(project, "def my_thing() d|", as_list: false)
     end
 
     test "returns an incomplete completion list when the context is empty", %{project: project} do
-      assert %Completion.List{is_incomplete: true, items: []} = complete(project, " ")
+      assert %Completion.List{is_incomplete: true, items: []} =
+               complete(project, " ", as_list: false)
     end
   end
 

apps/server/test/support/lexical/test/completion_case.ex

@@ -40,6 +40,7 @@ defmodule Lexical.Test.Server.CompletionCase do
   end
 
   def complete(project, text, opts \\ []) do
+    return_as_list? = Keyword.get(opts, :as_list, true)
     trigger_character = Keyword.get(opts, :trigger_character)
     root_path = Project.root_path(project)
 
@@ -69,11 +70,19 @@ defmodule Lexical.Test.Server.CompletionCase do
         CompletionContext.new(trigger_kind: :trigger_character)
       end
 
-    Completion.complete(project, document, position, context)
+    result = Completion.complete(project, document, position, context)
+
+    if return_as_list? do
+      completion_items(result)
+    else
+      result
+    end
   end
 
   def fetch_completion(completions, label_prefix) when is_binary(label_prefix) do
-    case Enum.filter(completions, &String.starts_with?(&1.label, label_prefix)) do
+    matcher = &String.starts_with?(&1.label, label_prefix)
+
+    case completions |> completion_items() |> Enum.filter(matcher) do
       [] -> {:error, :not_found}
       [found] -> {:ok, found}
       found when is_list(found) -> {:ok, found}
@@ -91,16 +100,7 @@ defmodule Lexical.Test.Server.CompletionCase do
       end)
     end
 
-    completion_enumerable =
-      case completions do
-        %CompletionList{} = completion_list ->
-          completion_list.items
-
-        list when is_list(list) ->
-          list
-      end
-
-    case Enum.filter(completion_enumerable, matcher) do
+    case completions |> completion_items() |> Enum.filter(matcher) do
       [] -> {:error, :not_found}
       [found] -> {:ok, found}
       found when is_list(found) -> {:ok, found}
@@ -122,4 +122,7 @@ defmodule Lexical.Test.Server.CompletionCase do
         false
     end
   end
+
+  defp completion_items(%CompletionList{items: items}), do: items
+  defp completion_items(items) when is_list(items), do: items
 end