fixup! wip

Author: mhanberg

apps/engine/lib/engine/engine/api.ex

@@ -109,7 +109,6 @@ defmodule Engine.Api do
   end
 
   def broadcast(%Project{} = project, message) do
-    dbg(message)
     Engine.call(project, Engine, :broadcast, [message])
   end
 

apps/engine/lib/engine/engine/api/proxy.ex

@@ -68,7 +68,6 @@ defmodule Engine.Api.Proxy do
 
   def broadcast(message) do
     mfa = to_mfa(Engine.Dispatch.broadcast(message))
-    dbg(mfa)
     :gen_statem.call(__MODULE__, buffer(contents: mfa))
   end
 

apps/engine/lib/engine/engine/dispatch.ex

@@ -40,7 +40,6 @@ defmodule Engine.Dispatch do
   end
 
   def broadcast(message) do
-    dbg(message)
     :gen_event.notify(__MODULE__, message)
   end
 

apps/engine/lib/engine/engine/dispatch/pub_sub.ex

@@ -22,9 +22,7 @@ defmodule Engine.Dispatch.PubSub do
 
     def registrations(%__MODULE__{} = state, message_type) do
       all = Map.get(state.registrations, :all, [])
-      dbg(all)
       specific = Map.get(state.registrations, message_type, [])
-      dbg(specific)
       all ++ specific
     end
 
@@ -102,13 +100,11 @@ defmodule Engine.Dispatch.PubSub do
 
   @impl :gen_event
   def handle_event(message, %State{} = state) do
-    dbg(message)
     message_type = extract_message_type(message)
 
     state
     |> State.registrations(message_type)
-    |> dbg()
-    |> Enum.each(&send(dbg(&1), message))
+    |> Enum.each(&send(&1, message))
 
     {:ok, state}
   end

apps/expert/lib/expert.ex

@@ -10,7 +10,6 @@ defmodule Expert do
 
   use GenLSP
 
-  # FIXME(mhanberg): these were not being namespaced correctly
   @server_specific_messages [
     GenLSP.Notifications.TextDocumentDidChange,
     GenLSP.Notifications.WorkspaceDidChangeConfiguration,
@@ -53,6 +52,7 @@ defmodule Expert do
         end
 
         lsp = assign(lsp, state: state)
+        {:ok, response} = Forge.Protocol.Convert.to_lsp(response)
 
         {:reply, response, lsp}
 
@@ -69,10 +69,11 @@ defmodule Expert do
   def handle_request(%mod{} = request, lsp) when mod in @server_specific_messages do
     GenLSP.error(lsp, "handling server specific request #{Macro.to_string(mod)}")
 
-    case apply_to_state(assigns(lsp).state, request) do
-      {:ok, response, state} ->
-        {:reply, response, assign(lsp, state: state)}
-
+    with {:ok, request} <- Forge.Protocol.Convert.to_native(request),
+         {:ok, response, state} <- apply_to_state(assigns(lsp).state, request),
+         {:ok, response} <- Forge.Protocol.Convert.to_lsp(response) do
+      {:reply, Forge.Protocol.Convert.to_lsp(response), assign(lsp, state: state)}
+    else
       error ->
         message = "Failed to handle #{mod}, #{inspect(error)}"
         Logger.error(message)
@@ -85,19 +86,13 @@ defmodule Expert do
     end
   end
 
-  # TODO: i'm not sure if we need this
-  # def handle_message(nil, %State{} = state) do
-  #   # NOTE: This deals with the response after a request is requested by the server,
-  #   # such as the response of `CreateWorkDoneProgress`.
-  #   {:ok, state}
-  # end
-
-  def handle_request(%_{} = request, lsp) do
+  def handle_request(request, lsp) do
     state = assigns(lsp).state
 
     with {:ok, handler} <- fetch_handler(request),
-         {:ok, req} <- Convert.to_native(request),
-         {:ok, response} <- handler.handle(req, state.configuration) do
+         {:ok, request} <- Convert.to_native(request),
+         {:ok, response} <- handler.handle(request, state.configuration),
+         {:ok, response} <- Forge.Protocol.Convert.to_lsp(response) do
       {:reply, response, lsp}
     else
       {:error, {:unhandled, _}} ->
@@ -109,30 +104,50 @@ defmodule Expert do
            message: "Method not found"
          }, lsp}
 
-      _ ->
-        {:noreply, lsp}
+      error ->
+        message = "Failed to handle #{request.method}, #{inspect(error)}"
+        Logger.error(message)
+
+        {:reply,
+         %GenLSP.ErrorResponse{
+           code: GenLSP.Enumerations.ErrorCodes.internal_error(),
+           message: message
+         }, lsp}
     end
   end
 
   def handle_notification(%mod{} = notification, lsp) when mod in @server_specific_messages do
-    GenLSP.error(lsp, "handling server specific notification #{Macro.to_string(mod)}")
-
-    case apply_to_state(assigns(lsp).state, notification) do
-      {:ok, state} ->
-        {:noreply, assign(lsp, state: state)}
-
+    with {:ok, notification} <- Convert.to_native(notification),
+         {:ok, state} <- apply_to_state(assigns(lsp).state, notification) do
+      {:noreply, assign(lsp, state: state)}
+    else
       error ->
-        message = "Failed to handle #{mod}, #{inspect(error)}"
+        message = "Failed to handle #{notification.method}, #{inspect(error)}"
         Logger.error(message)
 
         {:noreply, lsp}
     end
   end
 
-  def handle_notification(%mod{}, lsp) do
-    GenLSP.error(lsp, inspect(@server_specific_messages))
-    GenLSP.error(lsp, "handling other notification #{inspect(mod)}")
-    {:noreply, lsp}
+  def handle_notification(notification, lsp) do
+    state = assigns(lsp).state
+
+    with {:ok, handler} <- fetch_handler(notification),
+         {:ok, notification} <- Convert.to_native(notification),
+         {:ok, _response} <- handler.handle(notification, state.configuration) do
+      {:noreply, lsp}
+    else
+      {:error, {:unhandled, _}} ->
+        Logger.info("Unhandled notification: #{notification.method}")
+
+        {:noreply, lsp}
+
+      error ->
+        message = "Failed to handle #{notification.method}, #{inspect(error)}"
+        Logger.error(message)
+
+        {:noreply, lsp}
+    end
   end
 
   def handle_info(:default_config, %State{configuration: nil} = state) do

apps/expert/lib/expert/project/diagnostics.ex

@@ -62,8 +62,6 @@ defmodule Expert.Project.Diagnostics do
         file_diagnostics(uri: uri, build_number: build_number, diagnostics: diagnostics),
         %State{} = state
       ) do
-    dbg(diagnostics)
-
     state =
       case diagnostics do
         [] ->
@@ -94,14 +92,13 @@ defmodule Expert.Project.Diagnostics do
   # Private
 
   defp publish_diagnostics(%State{} = state) do
-    dbg(state)
-
     Enum.each(state.entries_by_uri, fn {uri, %State.Entry{} = entry} ->
-      diagnostics_list = State.Entry.diagnostics(entry)
-
-      GenLSP.notify(state.project.lsp, %TextDocumentPublishDiagnostics{
-        params: %Structures.PublishDiagnosticsParams{uri: uri, diagnostics: diagnostics_list}
-      })
+      with {:ok, diagnostics} <-
+             entry |> State.Entry.diagnostics() |> Forge.Protocol.Convert.to_lsp() do
+        GenLSP.notify(state.project.lsp, %TextDocumentPublishDiagnostics{
+          params: %Structures.PublishDiagnosticsParams{uri: uri, diagnostics: diagnostics}
+        })
+      end
     end)
   end
 

apps/expert/lib/expert/provider/handlers/completion.ex

@@ -9,8 +9,6 @@ defmodule Expert.Provider.Handlers.Completion do
   alias GenLSP.Structures
   alias GenLSP.Structures.CompletionContext
 
-  require Logger
-
   def handle(
         %Requests.TextDocumentCompletion{
           params: %Structures.CompletionParams{} = params

apps/expert/test/expert/project/diagnostics_test.exs

@@ -39,7 +39,6 @@ defmodule Expert.Project.DiagnosticsTest do
     test = self()
 
     patch(GenLSP, :notify_server, fn _, message ->
-      dbg(message)
       send(test, {:transport, message})
     end)
 
@@ -92,9 +91,7 @@ defmodule Expert.Project.DiagnosticsTest do
                         }
                       }}
 
-      dbg(self())
-
-      Document.Store.get_and_update(document.uri, &{:ok, Document.mark_clean(&1)}) |> dbg()
+      Document.Store.get_and_update(document.uri, &{:ok, Document.mark_clean(&1)})
 
       Engine.Api.broadcast(project, project_compile_requested())
       Engine.Api.broadcast(project, project_diagnostics(diagnostics: []))

apps/expert/test/support/test/dispatch_fake.ex

@@ -17,7 +17,6 @@ defmodule Expert.Test.DispatchFake do
       end)
 
       patch(Engine.Api, :broadcast, fn _project, message ->
-        dbg(message)
         Dispatch.broadcast(message)
       end)
 

apps/forge/lib/forge/document/store.ex

@@ -134,15 +134,11 @@ defmodule Forge.Document.Store do
     @spec get_and_update(t, Forge.uri(), Store.updater()) ::
             {:ok, Document.t(), t} | {:error, any()}
     def get_and_update(%__MODULE__{} = store, uri, updater_fn) do
-      dbg(self())
-
       with {:ok, open_doc(document: document)} <- Map.fetch(store.open, uri),
            {:ok, document} <- updater_fn.(document) do
-        dbg(document)
         {:ok, document, put_open_doc(store, document)}
       else
         error ->
-          dbg(error)
           normalize_error(error)
       end
     end