chore: use lsp workspace folder functionality

Author: doorgan

apps/expert/lib/expert.ex

@@ -14,11 +14,11 @@ defmodule Expert do
     GenLSP.Notifications.TextDocumentDidChange,
     GenLSP.Notifications.WorkspaceDidChangeConfiguration,
     GenLSP.Notifications.WorkspaceDidChangeWatchedFiles,
+    GenLSP.Notifications.WorkspaceDidChangeWorkspaceFolders,
     GenLSP.Notifications.TextDocumentDidClose,
     GenLSP.Notifications.TextDocumentDidOpen,
     GenLSP.Notifications.TextDocumentDidSave,
     GenLSP.Notifications.Exit,
-    GenLSP.Notifications.Initialized,
     GenLSP.Requests.Shutdown
   ]
 
@@ -47,13 +47,6 @@ defmodule Expert do
 
     case State.initialize(state, request) do
       {:ok, response, state} ->
-        # TODO: this should be gated behind the dynamic registration in the initialization params
-        registrations = registrations()
-
-        if nil != GenLSP.request(lsp, registrations) do
-          Logger.error("Failed to register capability")
-        end
-
         lsp = assign(lsp, state: state)
         {:ok, response} = Forge.Protocol.Convert.to_lsp(response)
 
@@ -119,6 +112,17 @@ defmodule Expert do
     end
   end
 
+  def handle_notification(%GenLSP.Notifications.Initialized{}, lsp) do
+    Logger.info("Server initialized, registering capabilities")
+    registrations = registrations()
+
+    if nil != GenLSP.request(lsp, registrations) do
+      Logger.error("Failed to register capability")
+    end
+
+    {:noreply, lsp}
+  end
+
   def handle_notification(%mod{} = notification, lsp) when mod in @server_specific_messages do
     with {:ok, notification} <- Convert.to_native(notification),
          {:ok, state} <- apply_to_state(assigns(lsp).state, notification) do

apps/expert/lib/expert/configuration.ex

@@ -29,11 +29,16 @@ defmodule Expert.Configuration do
 
   @dialyzer {:nowarn_function, set_dialyzer_enabled: 2}
 
-  @spec new(Forge.uri(), map(), String.t() | nil) :: t
-  def new(_root_uri, %Structures.ClientCapabilities{} = client_capabilities, client_name) do
+  @spec new([Structures.WorkspaceFolder.t()], map(), String.t() | nil) :: t
+  def new(workspace_folders, %Structures.ClientCapabilities{} = client_capabilities, client_name) do
     support = Support.new(client_capabilities)
 
-    %__MODULE__{support: support, projects: [], client_name: client_name}
+    projects =
+      for %{uri: uri} <- workspace_folders do
+        Project.new(uri)
+      end
+
+    %__MODULE__{support: support, projects: projects, client_name: client_name}
     |> tap(&set/1)
   end
 
@@ -143,17 +148,29 @@ defmodule Expert.Configuration do
     {:ok, old_config}
   end
 
-  @spec add_project(t, Project.t()) :: t
-  def add_project(%__MODULE__{} = config, %Project{} = project) do
-    if Enum.any?(config.projects, &(&1.root_uri == project.root_uri)) do
-      config
-    else
-      projects = [project | config.projects]
-      new_config = %__MODULE__{config | projects: projects}
+  @spec add_projects(t, [Project.t()]) :: t
+  def add_projects(%__MODULE__{} = config, projects) do
+    new_config =
+      for project <- projects, reduce: config do
+        config ->
+          if Enum.any?(config.projects, &(&1.root_uri == project.root_uri)) do
+            config
+          else
+            projects = [project | config.projects]
+            %__MODULE__{config | projects: projects}
+          end
+      end
+
+    set(new_config)
 
-      set(new_config)
+    new_config
+  end
 
-      new_config
-    end
+  @spec remove_projects(t, [String.t()]) :: t
+  def remove_projects(%__MODULE__{} = config, projects) do
+    new_projects = Enum.reject(config.projects, &(&1.root_uri in projects))
+    new_config = %__MODULE__{config | projects: new_projects}
+    set(new_config)
+    new_config
   end
 end

apps/expert/lib/expert/project/supervisor.ex

@@ -7,16 +7,6 @@ defmodule Expert.Project.Supervisor do
   alias Expert.Project.SearchListener
   alias Forge.Project
 
-  # TODO: this module is slightly weird
-  # it is a module based supervisor, but has lots of dynamic supervisor functions
-  # what I learned is that in Expert.Application, it is starting an ad hoc
-  # dynamic supervisor, calling a function from this module
-  # Later, when the server is initializing, it calls the start function in
-  # this module, which starts a normal supervisor, which the start_link and
-  # init callbacks will be called
-  # my suggestion is to separate the dynamic supervisor functionalities from
-  # this module into its own module
-
   use Supervisor
 
   def start_link(%Project{} = project) do

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

@@ -1,7 +1,7 @@
 defmodule Expert.Provider.Handlers.GoToDefinition do
   alias Expert.Configuration
-  alias Forge.Project
   alias Expert.EngineApi
+  alias Forge.Project
   alias GenLSP.Requests
   alias GenLSP.Structures
 

apps/expert/lib/expert/state.ex

@@ -18,7 +18,8 @@ defmodule Expert.State do
   defstruct configuration: nil,
             initialized?: false,
             shutdown_received?: false,
-            in_flight_requests: %{}
+            in_flight_requests: %{},
+            workspace_folders: []
 
   @supported_code_actions [
     Enumerations.CodeActionKind.quick_fix(),
@@ -55,11 +56,15 @@ defmodule Expert.State do
     |> Forge.Workspace.new()
     |> Forge.Workspace.set_workspace()
 
-    config = Configuration.new(event.root_uri, event.capabilities, client_name)
+    config = Configuration.new(event.workspace_folders, event.capabilities, client_name)
     new_state = %__MODULE__{state | configuration: config, initialized?: true}
 
     response = initialize_result()
 
+    for project <- config.projects do
+      ensure_project_node_started(project)
+    end
+
     {:ok, response, new_state}
   end
 
@@ -100,6 +105,39 @@ defmodule Expert.State do
     {:ok, state}
   end
 
+  def apply(%__MODULE__{} = state, %Notifications.WorkspaceDidChangeWorkspaceFolders{
+        params:
+          %Structures.DidChangeWorkspaceFoldersParams{
+            event: %Structures.WorkspaceFoldersChangeEvent{added: added, removed: removed}
+          } = params
+      }) do
+    workspace_folders = [added | state.workspace_folders] -- removed
+
+    removed_projects =
+      for %{uri: uri} <- removed do
+        project = Project.new(uri)
+        Logger.info("Stopping project at uri #{uri}")
+        Expert.Project.Supervisor.stop(project)
+        project
+      end
+
+    added_projects =
+      for %{uri: uri} <- added do
+        project = Project.new(uri)
+        ensure_project_node_started(project)
+        project
+      end
+
+    config =
+      state.configuration
+      |> Configuration.add_projects(added_projects)
+      |> Configuration.remove_projects(removed_projects)
+
+    state = %__MODULE__{state | configuration: config, workspace_folders: workspace_folders}
+
+    {:ok, state}
+  end
+
   def apply(%__MODULE__{} = state, %GenLSP.Notifications.TextDocumentDidChange{params: params}) do
     uri = params.text_document.uri
     version = params.text_document.version
@@ -136,18 +174,6 @@ defmodule Expert.State do
       language_id: language_id
     } = did_open.params.text_document
 
-    project = Project.find_project(uri)
-    config = state.configuration
-
-    state =
-      if is_nil(project) do
-        state
-      else
-        maybe_start_project(project, config)
-        config = Configuration.add_project(config, project)
-        %__MODULE__{state | configuration: config}
-      end
-
     case Document.Store.open(uri, text, version, language_id) do
       :ok ->
         Logger.info("################### opened #{uri}")
@@ -216,19 +242,18 @@ defmodule Expert.State do
     {:ok, state}
   end
 
-  defp maybe_start_project(project, config) do
-    already_started? =
-      Enum.any?(config.projects, fn p ->
-        p.root_uri == project.root_uri
-      end)
-
-    if already_started? do
-      :ok
-    else
-      Logger.info("Starting project at uri #{project.root_uri}")
-      result = Expert.Project.Supervisor.start(project)
-      Logger.info("result: #{inspect(result)}")
-      :ok
+  defp ensure_project_node_started(project) do
+    case Expert.Project.Supervisor.start(project) do
+      {:ok, _pid} ->
+        Logger.info("Project node started for #{project.name}")
+
+      {:error, {reason, pid}} when reason in [:alread_started, :already_present] ->
+        {:ok, pid}
+
+      {:error, reason} ->
+        Logger.error(
+          "Failed to start project node for #{project.name}: #{inspect(reason, pretty: true)}"
+        )
     end
   end
 
@@ -269,7 +294,13 @@ defmodule Expert.State do
         hover_provider: true,
         references_provider: true,
         text_document_sync: sync_options,
-        workspace_symbol_provider: true
+        workspace_symbol_provider: true,
+        workspace: %{
+          workspace_folders: %Structures.WorkspaceFoldersServerCapabilities{
+            supported: true,
+            change_notifications: true
+          }
+        }
       }
 
     %GenLSP.Structures.InitializeResult{

apps/forge/lib/forge/project.ex

@@ -373,37 +373,4 @@ defmodule Forge.Project do
       Forge.Path.parent_path?(document.path, root_path(project))
     end)
   end
-
-  def find_project(path) do
-    project_root = find_parent_root_dir(path)
-
-    if is_nil(project_root) do
-      nil
-    else
-      new(project_root)
-    end
-  end
-
-  defp find_parent_root_dir(path) do
-    path = Forge.Document.Path.from_uri(path)
-    path = path |> Path.expand() |> Path.dirname()
-
-    segments = Path.split(path)
-
-    traverse_path(segments)
-  end
-
-  defp traverse_path([]), do: nil
-
-  defp traverse_path(segments) do
-    path = Path.join(segments)
-    mix_exs_path = Path.join(path, "mix.exs")
-
-    if File.exists?(mix_exs_path) do
-      Document.Path.to_uri(path)
-    else
-      {_, rest} = List.pop_at(segments, -1)
-      traverse_path(rest)
-    end
-  end
 end