Refactor request handling (#777)

* Delete `Provider.Env` in favor of passing server config

* Delete unused provider `:reply_and_alert` response and relevant handling

* Use consistent field name convention in provider queue

* Don't normalize request IDs to strings

* Explicitly start a task supervisor for the provider queue

* Refactor `Provider.Queue` -> `TaskQueue`

* Delete `Server.Provider.Handlers` and move only fun into `Server`

apps/server/lib/lexical/server.ex

@@ -1,9 +1,10 @@
 defmodule Lexical.Server do
+  alias Lexical.Proto.Convert
   alias Lexical.Protocol.Notifications
   alias Lexical.Protocol.Requests
-  alias Lexical.Protocol.Responses
-  alias Lexical.Server.Provider
+  alias Lexical.Server.Provider.Handlers
   alias Lexical.Server.State
+  alias Lexical.Server.TaskQueue
 
   require Logger
 
@@ -23,11 +24,6 @@ defmodule Lexical.Server do
 
   @dialyzer {:nowarn_function, apply_to_state: 2}
 
-  @spec response_complete(Requests.request(), Responses.response()) :: :ok
-  def response_complete(request, response) do
-    GenServer.call(__MODULE__, {:response_complete, request, response})
-  end
-
   @spec server_request(
           Requests.request(),
           (Requests.request(), {:ok, any()} | {:error, term()} -> term())
@@ -53,10 +49,6 @@ defmodule Lexical.Server do
     {:ok, State.new()}
   end
 
-  def handle_call({:response_complete, _request, _response}, _from, %State{} = state) do
-    {:reply, :ok, state}
-  end
-
   def handle_call({:server_request, request, on_response}, _from, %State{} = state) do
     new_state = State.add_request(state, request, on_response)
     {:reply, :okk, new_state}
@@ -111,12 +103,12 @@ defmodule Lexical.Server do
   end
 
   def handle_message(%Requests.Cancel{} = cancel_request, %State{} = state) do
-    Provider.Queue.cancel(cancel_request)
+    TaskQueue.cancel(cancel_request)
     {:ok, state}
   end
 
   def handle_message(%Notifications.Cancel{} = cancel_notification, %State{} = state) do
-    Provider.Queue.cancel(cancel_notification)
+    TaskQueue.cancel(cancel_notification)
     {:ok, state}
   end
 
@@ -138,13 +130,22 @@ defmodule Lexical.Server do
   end
 
   def handle_message(%_{} = request, %State{} = state) do
-    Provider.Queue.add(request, state.configuration)
+    with {:ok, handler} <- fetch_handler(request),
+         {:ok, req} <- Convert.to_native(request) do
+      TaskQueue.add(request.id, {handler, :handle, [req, state.configuration.project]})
+    else
+      {:error, {:unhandled, _}} ->
+        Logger.info("Unhandled request: #{request.method}")
+
+      _ ->
+        :ok
+    end
 
     {:ok, state}
   end
 
-  def handle_message(%{} = request, %State{} = state) do
-    new_state = State.finish_request(state, request)
+  def handle_message(%{} = response, %State{} = state) do
+    new_state = State.finish_request(state, response)
 
     {:ok, new_state}
   end
@@ -156,4 +157,42 @@ defmodule Lexical.Server do
       error -> {error, state}
     end
   end
+
+  # credo:disable-for-next-line Credo.Check.Refactor.CyclomaticComplexity
+  defp fetch_handler(%_{} = request) do
+    case request do
+      %Requests.FindReferences{} ->
+        {:ok, Handlers.FindReferences}
+
+      %Requests.Formatting{} ->
+        {:ok, Handlers.Formatting}
+
+      %Requests.CodeAction{} ->
+        {:ok, Handlers.CodeAction}
+
+      %Requests.CodeLens{} ->
+        {:ok, Handlers.CodeLens}
+
+      %Requests.Completion{} ->
+        {:ok, Handlers.Completion}
+
+      %Requests.GoToDefinition{} ->
+        {:ok, Handlers.GoToDefinition}
+
+      %Requests.Hover{} ->
+        {:ok, Handlers.Hover}
+
+      %Requests.ExecuteCommand{} ->
+        {:ok, Handlers.Commands}
+
+      %Requests.DocumentSymbols{} ->
+        {:ok, Handlers.DocumentSymbols}
+
+      %Requests.WorkspaceSymbol{} ->
+        {:ok, Handlers.WorkspaceSymbol}
+
+      %request_module{} ->
+        {:error, {:unhandled, request_module}}
+    end
+  end
 end

apps/server/lib/lexical/server/application.ex

@@ -5,7 +5,7 @@ defmodule Lexical.Server.Application do
 
   alias Lexical.Document
   alias Lexical.Server
-  alias Lexical.Server.Provider
+  alias Lexical.Server.TaskQueue
   alias Lexical.Server.Transport
 
   use Application
@@ -16,8 +16,8 @@ defmodule Lexical.Server.Application do
       document_store_child_spec(),
       Server,
       {DynamicSupervisor, Server.Project.Supervisor.options()},
-      Provider.Queue.Supervisor.child_spec(),
-      Provider.Queue.child_spec(),
+      {Task.Supervisor, name: TaskQueue.task_supervisor_name()},
+      TaskQueue,
       {Transport.StdIO, [:standard_io, &Server.protocol_message/1]}
     ]
 

apps/server/lib/lexical/server/configuration.ex

@@ -40,9 +40,9 @@ defmodule Lexical.Server.Configuration do
     |> tap(&set/1)
   end
 
-  @spec new() :: t
-  def new do
-    %__MODULE__{support: Support.new()}
+  @spec new(keyword()) :: t
+  def new(attrs \\ []) do
+    struct!(__MODULE__, [support: Support.new()] ++ attrs)
   end
 
   defp set(%__MODULE__{} = config) do

apps/server/lib/lexical/server/provider/handlers/code_action.ex

@@ -5,16 +5,16 @@ defmodule Lexical.Server.Provider.Handlers.CodeAction do
   alias Lexical.Protocol.Types.Workspace
   alias Lexical.RemoteControl
   alias Lexical.RemoteControl.CodeAction
-  alias Lexical.Server.Provider.Env
+  alias Lexical.Server.Configuration
 
   require Logger
 
-  def handle(%Requests.CodeAction{} = request, %Env{} = env) do
+  def handle(%Requests.CodeAction{} = request, %Configuration{} = config) do
     diagnostics = Enum.map(request.context.diagnostics, &to_code_action_diagnostic/1)
 
     code_actions =
       RemoteControl.Api.code_actions(
-        env.project,
+        config.project,
         request.document,
         request.range,
         diagnostics,

apps/server/lib/lexical/server/provider/handlers/code_lens.ex

@@ -7,15 +7,15 @@ defmodule Lexical.Server.Provider.Handlers.CodeLens do
   alias Lexical.Protocol.Responses
   alias Lexical.Protocol.Types.CodeLens
   alias Lexical.RemoteControl
-  alias Lexical.Server.Provider.Env
+  alias Lexical.Server.Configuration
   alias Lexical.Server.Provider.Handlers
 
   import Document.Line
   require Logger
 
-  def handle(%Requests.CodeLens{} = request, %Env{} = env) do
+  def handle(%Requests.CodeLens{} = request, %Configuration{} = config) do
     lenses =
-      case reindex_lens(env.project, request.document) do
+      case reindex_lens(config.project, request.document) do
         nil -> []
         lens -> List.wrap(lens)
       end

apps/server/lib/lexical/server/provider/handlers/commands.ex

@@ -5,7 +5,7 @@ defmodule Lexical.Server.Provider.Handlers.Commands do
   alias Lexical.Protocol.Types
   alias Lexical.Protocol.Types.ErrorCodes
   alias Lexical.RemoteControl
-  alias Lexical.Server.Provider.Env
+  alias Lexical.Server.Configuration
   alias Lexical.Server.Window
 
   require ErrorCodes
@@ -26,12 +26,12 @@ defmodule Lexical.Server.Provider.Handlers.Commands do
     )
   end
 
-  def handle(%Requests.ExecuteCommand{} = request, %Env{} = env) do
+  def handle(%Requests.ExecuteCommand{} = request, %Configuration{} = config) do
     response =
       case request.command do
         @reindex_name ->
-          Logger.info("Reindex #{Project.name(env.project)}")
-          reindex(env.project, request.id)
+          Logger.info("Reindex #{Project.name(config.project)}")
+          reindex(config.project, request.id)
 
         invalid ->
           message = "#{invalid} is not a valid command"

apps/server/lib/lexical/server/provider/handlers/completion.ex

@@ -6,14 +6,14 @@ defmodule Lexical.Server.Provider.Handlers.Completion do
   alias Lexical.Protocol.Responses
   alias Lexical.Protocol.Types.Completion
   alias Lexical.Server.CodeIntelligence
-  alias Lexical.Server.Provider.Env
+  alias Lexical.Server.Configuration
 
   require Logger
 
-  def handle(%Requests.Completion{} = request, %Env{} = env) do
+  def handle(%Requests.Completion{} = request, %Configuration{} = config) do
     completions =
       CodeIntelligence.Completion.complete(
-        env.project,
+        config.project,
         document_analysis(request.document, request.position),
         request.position,
         request.context || Completion.Context.new(trigger_kind: :invoked)

apps/server/lib/lexical/server/provider/handlers/document_symbols.ex

@@ -6,13 +6,13 @@ defmodule Lexical.Server.Provider.Handlers.DocumentSymbols do
   alias Lexical.Protocol.Types.Symbol.Kind, as: SymbolKind
   alias Lexical.RemoteControl.Api
   alias Lexical.RemoteControl.CodeIntelligence.Symbols
-  alias Lexical.Server.Provider.Env
+  alias Lexical.Server.Configuration
 
   require SymbolKind
 
-  def handle(%DocumentSymbols{} = request, %Env{} = env) do
+  def handle(%DocumentSymbols{} = request, %Configuration{} = config) do
     symbols =
-      env.project
+      config.project
       |> Api.document_symbols(request.document)
       |> Enum.map(&to_response(&1, request.document))
 

apps/server/lib/lexical/server/provider/handlers/find_references.ex

@@ -4,17 +4,17 @@ defmodule Lexical.Server.Provider.Handlers.FindReferences do
   alias Lexical.Protocol.Requests.FindReferences
   alias Lexical.Protocol.Responses
   alias Lexical.RemoteControl.Api
-  alias Lexical.Server.Provider.Env
+  alias Lexical.Server.Configuration
 
   require Logger
 
-  def handle(%FindReferences{} = request, %Env{} = env) do
+  def handle(%FindReferences{} = request, %Configuration{} = config) do
     include_declaration? = !!request.context.include_declaration
 
     locations =
       case Document.Store.fetch(request.document.uri, :analysis) do
         {:ok, _document, %Ast.Analysis{} = analysis} ->
-          Api.references(env.project, analysis, request.position, include_declaration?)
+          Api.references(config.project, analysis, request.position, include_declaration?)
 
         _ ->
           nil

apps/server/lib/lexical/server/provider/handlers/formatting.ex

@@ -3,14 +3,14 @@ defmodule Lexical.Server.Provider.Handlers.Formatting do
   alias Lexical.Protocol.Requests
   alias Lexical.Protocol.Responses
   alias Lexical.RemoteControl
-  alias Lexical.Server.Provider.Env
+  alias Lexical.Server.Configuration
 
   require Logger
 
-  def handle(%Requests.Formatting{} = request, %Env{} = env) do
+  def handle(%Requests.Formatting{} = request, %Configuration{} = config) do
     document = request.document
 
-    case RemoteControl.Api.format(env.project, document) do
+    case RemoteControl.Api.format(config.project, document) do
       {:ok, %Changes{} = document_edits} ->
         response = Responses.Formatting.new(request.id, document_edits)
         Logger.info("Response #{inspect(response)}")

apps/server/lib/lexical/server/provider/handlers/go_to_definition.ex

@@ -2,11 +2,12 @@ defmodule Lexical.Server.Provider.Handlers.GoToDefinition do
   alias Lexical.Protocol.Requests.GoToDefinition
   alias Lexical.Protocol.Responses
   alias Lexical.RemoteControl
+  alias Lexical.Server.Configuration
 
   require Logger
 
-  def handle(%GoToDefinition{} = request, env) do
-    case RemoteControl.Api.definition(env.project, request.document, request.position) do
+  def handle(%GoToDefinition{} = request, %Configuration{} = config) do
+    case RemoteControl.Api.definition(config.project, request.document, request.position) do
       {:ok, native_location} ->
         {:reply, Responses.GoToDefinition.new(request.id, native_location)}