Add support for completions in debugger (#679)

* fix typo

* warn about not supported client options

* Add support for debugger completions

Author: lukaszsamson

apps/elixir_ls_debugger/lib/debugger/completions.ex

@@ -0,0 +1,56 @@
+defmodule ElixirLS.Debugger.Completions do
+  # type CompletionItemType = 'method' | 'function' | 'constructor' | 'field'
+  #   | 'variable' | 'class' | 'interface' | 'module' | 'property' | 'unit'
+  #   | 'value' | 'enum' | 'keyword' | 'snippet' | 'text' | 'color' | 'file'
+  #   | 'reference' | 'customcolor';
+  def map(%{
+        type: type,
+        name: name,
+        arity: arity,
+        snippet: snippet
+      })
+      when type in [:function, :macro] do
+    %{
+      type: "function",
+      label: "#{name}/#{arity}",
+      text: snippet || name
+    }
+  end
+
+  def map(%{
+        type: :module,
+        name: name
+      }) do
+    text =
+      case name do
+        ":" <> rest -> rest
+        other -> other
+      end
+
+    %{
+      type: "module",
+      label: name,
+      text: text
+    }
+  end
+
+  def map(%{
+        type: :variable,
+        name: name
+      }) do
+    %{
+      type: "variable",
+      label: name
+    }
+  end
+
+  def map(%{
+        type: :field,
+        name: name
+      }) do
+    %{
+      type: "field",
+      label: name
+    }
+  end
+end

apps/elixir_ls_debugger/lib/debugger/protocol.ex

@@ -85,6 +85,12 @@ defmodule ElixirLS.Debugger.Protocol do
     end
   end
 
+  defmacro completions_req(seq, text) do
+    quote do
+      request(unquote(seq), "completions", %{"text" => unquote(text)})
+    end
+  end
+
   defmacro continue_req(seq, thread_id) do
     quote do
       request(unquote(seq), "continue", %{"threadId" => unquote(thread_id)})

apps/elixir_ls_debugger/lib/debugger/server.ex

@@ -228,6 +228,21 @@ defmodule ElixirLS.Debugger.Server do
   ## Helpers
 
   defp handle_request(initialize_req(_, client_info), %__MODULE__{client_info: nil} = state) do
+    # linesStartAt1 is true by default and we only support 1-based indexing
+    if client_info["linesStartAt1"] == false do
+      IO.warn("0-based lines are not supported")
+    end
+
+    # columnsStartAt1 is true by default and we only support 1-based indexing
+    if client_info["columnsStartAt1"] == false do
+      IO.warn("0-based columns are not supported")
+    end
+
+    # pathFormat is `path` by default and we do not support other, e.g. `uri`
+    if client_info["pathFormat"] not in [nil, "path"] do
+      IO.warn("pathFormat #{client_info["pathFormat"]} not supported")
+    end
+
     {capabilities(), %{state | client_info: client_info}}
   end
 
@@ -240,7 +255,11 @@ defmodule ElixirLS.Debugger.Server do
       }
   end
 
-  defp handle_request(launch_req(_, config), state = %__MODULE__{}) do
+  defp handle_request(launch_req(_, config) = args, state = %__MODULE__{}) do
+    if args["arguments"]["noDebug"] == true do
+      IO.warn("launch with no debug is not supported")
+    end
+
     {_, ref} = spawn_monitor(fn -> initialize(config) end)
 
     receive do
@@ -629,6 +648,39 @@ defmodule ElixirLS.Debugger.Server do
      %{state | paused_processes: maybe_continue_other_processes(args, paused_processes, pid)}}
   end
 
+  defp handle_request(completions_req(_, text) = args, state = %__MODULE__{}) do
+    # assume that the position is 1-based
+    line = (args["arguments"]["line"] || 1) - 1
+    column = (args["arguments"]["column"] || 1) - 1
+
+    # for simplicity take only text from the given line up to column
+    line =
+      text
+      |> String.split(["\r\n", "\n", "\r"])
+      |> Enum.at(line)
+
+    # it's not documented but VSCode uses utf16 positions
+    column = Utils.dap_character_to_elixir(line, column)
+    prefix = String.slice(line, 0, column)
+
+    vars =
+      all_variables(state.paused_processes, args["arguments"]["frameId"])
+      |> Enum.map(fn {name, value} ->
+        %ElixirSense.Core.State.VarInfo{
+          name: name,
+          type: ElixirSense.Core.Binding.from_var(value)
+        }
+      end)
+
+    env = %ElixirSense.Providers.Suggestion.Complete.Env{vars: vars}
+
+    results =
+      ElixirSense.Providers.Suggestion.Complete.complete(prefix, env)
+      |> Enum.map(&ElixirLS.Debugger.Completions.map/1)
+
+    {%{"targets" => results}, state}
+  end
+
   defp handle_request(request(_, command), _state = %__MODULE__{}) when is_binary(command) do
     raise ServerError,
       message: "notSupported",
@@ -961,7 +1013,8 @@ defmodule ElixirLS.Debugger.Server do
       "supportsRestartFrame" => false,
       "supportsGotoTargetsRequest" => false,
       "supportsStepInTargetsRequest" => false,
-      "supportsCompletionsRequest" => false,
+      "supportsCompletionsRequest" => true,
+      "completionTriggerCharacters" => [".", "&", "%", "^", ":", "!", "-", "~"],
       "supportsModulesRequest" => false,
       "additionalModuleColumns" => [],
       "supportedChecksumAlgorithms" => [],

apps/elixir_ls_debugger/lib/debugger/utils.ex

@@ -18,4 +18,35 @@ defmodule ElixirLS.Debugger.Utils do
         {:error, "cannot parse MFA"}
     end
   end
+
+  defp characters_to_binary!(binary, from, to) do
+    case :unicode.characters_to_binary(binary, from, to) do
+      result when is_binary(result) -> result
+    end
+  end
+
+  def dap_character_to_elixir(_utf8_line, dap_character) when dap_character <= 0, do: 0
+
+  def dap_character_to_elixir(utf8_line, dap_character) do
+    utf16_line =
+      utf8_line
+      |> characters_to_binary!(:utf8, :utf16)
+
+    byte_size = byte_size(utf16_line)
+
+    # if character index is over the length of the string assume we pad it with spaces (1 byte in utf8)
+    diff = div(max(dap_character * 2 - byte_size, 0), 2)
+
+    utf8_character =
+      utf16_line
+      |> (&binary_part(
+            &1,
+            0,
+            min(dap_character * 2, byte_size)
+          )).()
+      |> characters_to_binary!(:utf16, :utf8)
+      |> String.length()
+
+    utf8_character + diff
+  end
 end

apps/elixir_ls_debugger/test/debugger_test.exs

@@ -1545,4 +1545,28 @@ defmodule ElixirLS.Debugger.ServerTest do
       assert Process.alive?(server)
     end
   end
+
+  test "Completions", %{server: server} do
+    Server.receive_packet(server, initialize_req(1, %{}))
+    assert_receive(response(_, 1, "initialize", _))
+
+    Server.receive_packet(
+      server,
+      %{
+        "arguments" => %{
+          "text" => "DateTi",
+          "column" => 7
+        },
+        "command" => "completions",
+        "seq" => 1,
+        "type" => "request"
+      }
+    )
+
+    assert_receive(%{"body" => %{"targets" => _targets}}, 10000)
+
+    assert Process.alive?(server)
+
+    # assert [%{}]
+  end
 end

apps/elixir_ls_debugger/test/utils_test.exs

@@ -33,4 +33,22 @@ defmodule ElixirLS.Debugger.UtilsTest do
       assert {:error, "cannot parse MFA"} == Utils.parse_mfa("")
     end
   end
+
+  describe "positions" do
+    test "dap_character_to_elixir empty" do
+      assert 0 == Utils.dap_character_to_elixir("", 0)
+    end
+
+    test "dap_character_to_elixir first char" do
+      assert 0 == Utils.dap_character_to_elixir("abcde", 0)
+    end
+
+    test "dap_character_to_elixir line" do
+      assert 1 == Utils.dap_character_to_elixir("abcde", 1)
+    end
+
+    test "dap_character_to_elixir utf8" do
+      assert 1 == Utils.dap_character_to_elixir("🏳️‍🌈abcde", 6)
+    end
+  end
 end

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

@@ -6,7 +6,7 @@ defmodule ElixirLS.LanguageServer.Providers.Definition do
   alias ElixirLS.LanguageServer.{Protocol, SourceFile}
 
   def definition(uri, text, line, character) do
-    {line, character} = SourceFile.lsp_position_to_elixr(text, {line, character})
+    {line, character} = SourceFile.lsp_position_to_elixir(text, {line, character})
 
     result =
       case ElixirSense.definition(text, line, character) do

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

@@ -18,7 +18,7 @@ defmodule ElixirLS.LanguageServer.Providers.Hover do
                 |> Enum.map(fn x -> "lib/#{x}/lib" end)
 
   def hover(text, line, character, project_dir) do
-    {line, character} = SourceFile.lsp_position_to_elixr(text, {line, character})
+    {line, character} = SourceFile.lsp_position_to_elixir(text, {line, character})
 
     response =
       case ElixirSense.docs(text, line, character) do

apps/language_server/lib/language_server/providers/implementation.ex

@@ -6,7 +6,7 @@ defmodule ElixirLS.LanguageServer.Providers.Implementation do
   alias ElixirLS.LanguageServer.{Protocol, SourceFile}
 
   def implementation(uri, text, line, character) do
-    {line, character} = SourceFile.lsp_position_to_elixr(text, {line, character})
+    {line, character} = SourceFile.lsp_position_to_elixir(text, {line, character})
     locations = ElixirSense.implementations(text, line, character)
     results = for location <- locations, do: Protocol.Location.new(location, uri, text)
 

apps/language_server/lib/language_server/providers/references.ex

@@ -14,7 +14,7 @@ defmodule ElixirLS.LanguageServer.Providers.References do
   import ElixirLS.LanguageServer.Protocol
 
   def references(text, uri, line, character, _include_declaration) do
-    {line, character} = SourceFile.lsp_position_to_elixr(text, {line, character})
+    {line, character} = SourceFile.lsp_position_to_elixir(text, {line, character})
 
     Build.with_build_lock(fn ->
       ElixirSense.references(text, line, character)