feat: workspace folders

apps/engine/benchmarks/ast_analyze.exs

@@ -1,3 +1,5 @@
+Mix.install([:benchee])
+
 alias Forge.Ast
 alias Forge.Document
 

apps/engine/benchmarks/enum_index.exs

@@ -1,3 +1,5 @@
+Mix.install([:benchee])
+
 alias Engine.Search.Indexer
 
 path =

apps/engine/benchmarks/ets_bench.exs

@@ -1,3 +1,5 @@
+Mix.install([:benchee])
+
 alias Forge.Project
 
 alias Engine.Search.Store.Backends.Ets

apps/engine/benchmarks/versions_bench.exs

@@ -1,3 +1,5 @@
+Mix.install([:benchee])
+
 alias Forge.VM.Versions
 
 Benchee.run(%{

apps/engine/mix.exs

@@ -44,7 +44,6 @@ defmodule Engine.MixProject do
 
   defp deps do
     [
-      {:benchee, "~> 1.3", only: :test},
       {:deps_nix, "~> 2.4", only: :dev},
       Mix.Credo.dependency(),
       Mix.Dialyzer.dependency(),

apps/expert/config/runtime.exs

@@ -20,5 +20,3 @@ if Code.ensure_loaded?(LoggerFileBackend) do
 else
   :ok
 end
-
-require Logger

apps/expert/lib/expert.ex

@@ -1,8 +1,10 @@
 defmodule Expert do
+  alias Expert.ActiveProjects
   alias Expert.Protocol.Convert
   alias Expert.Protocol.Id
   alias Expert.Provider.Handlers
   alias Expert.State
+  alias Forge.Project
   alias GenLSP.Requests
   alias GenLSP.Structures
 
@@ -14,6 +16,7 @@ defmodule Expert do
     GenLSP.Notifications.TextDocumentDidChange,
     GenLSP.Notifications.WorkspaceDidChangeConfiguration,
     GenLSP.Notifications.WorkspaceDidChangeWatchedFiles,
+    GenLSP.Notifications.WorkspaceDidChangeWorkspaceFolders,
     GenLSP.Notifications.TextDocumentDidClose,
     GenLSP.Notifications.TextDocumentDidOpen,
     GenLSP.Notifications.TextDocumentDidSave,
@@ -93,43 +96,74 @@ defmodule Expert do
   def handle_request(request, lsp) do
     state = assigns(lsp).state
 
-    if state.engine_initialized? do
-      with {:ok, handler} <- fetch_handler(request),
-           {:ok, request} <- Convert.to_native(request),
-           {:ok, response} <- handler.handle(request, state.configuration),
-           {:ok, response} <- Expert.Protocol.Convert.to_lsp(response) do
-        {:reply, response, lsp}
-      else
-        {:error, {:unhandled, _}} ->
-          Logger.info("Unhandled request: #{request.method}")
-
-          {:reply,
-           %GenLSP.ErrorResponse{
-             code: GenLSP.Enumerations.ErrorCodes.method_not_found(),
-             message: "Method not found"
-           }, 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
+    with {:ok, handler} <- fetch_handler(request),
+         {:ok, request} <- Convert.to_native(request),
+         :ok <- check_engine_initialized(request),
+         {:ok, response} <- handler.handle(request, state.configuration),
+         {:ok, response} <- Expert.Protocol.Convert.to_lsp(response) do
+      {:reply, response, lsp}
     else
-      GenLSP.warning(
-        lsp,
-        "Received request #{request.method} before engine was initialized. Ignoring."
-      )
+      {:error, {:unhandled, _}} ->
+        Logger.info("Unhandled request: #{request.method}")
 
-      {:noreply, lsp}
+        {:reply,
+         %GenLSP.ErrorResponse{
+           code: GenLSP.Enumerations.ErrorCodes.method_not_found(),
+           message: "Method not found"
+         }, lsp}
+
+      {:error, :engine_not_initialized, project} ->
+        GenLSP.info(
+          lsp,
+          "Received request #{request.method} before engine for #{project && Project.name(project)} was initialized. Ignoring."
+        )
+
+        {:reply, nil, 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
 
+  defp check_engine_initialized(request) do
+    if document_request?(request) do
+      case Forge.Document.Container.context_document(request, nil) do
+        %Forge.Document{} = document ->
+          projects = ActiveProjects.projects()
+          project = Project.project_for_document(projects, document)
+
+          if ActiveProjects.active?(project) do
+            :ok
+          else
+            {:error, :engine_not_initialized, project}
+          end
+
+        nil ->
+          {:error, :engine_not_initialized, nil}
+      end
+    else
+      :ok
+    end
+  end
+
+  defp document_request?(%{document: %Forge.Document{}}), do: true
+
+  defp document_request?(%{params: params}) do
+    document_request?(params)
+  end
+
+  defp document_request?(%{text_document: %{uri: _}}), do: true
+  defp document_request?(_), do: false
+
   def handle_notification(%GenLSP.Notifications.Initialized{}, lsp) do
+    Logger.info("Server initialized, registering capabilities")
     registrations = registrations()
 
     if nil != GenLSP.request(lsp, registrations) do
@@ -173,18 +207,6 @@ defmodule Expert do
     end
   end
 
-  def handle_info(:engine_initialized, lsp) do
-    state = assigns(lsp).state
-
-    new_state = %{state | engine_initialized?: true}
-
-    lsp = assign(lsp, state: new_state)
-
-    Logger.info("Engine initialized")
-
-    {:noreply, lsp}
-  end
-
   def handle_info(:default_config, lsp) do
     state = assigns(lsp).state
 

apps/expert/lib/expert/active_projects.ex

@@ -0,0 +1,70 @@
+defmodule Expert.ActiveProjects do
+  @moduledoc """
+  A cache to keep track of active projects.
+
+  Since GenLSP events happen asynchronously, we use an ets table to keep track of
+  them and avoid race conditions when we try to update the list of active projects.
+  """
+  alias Forge.Project
+
+  use GenServer
+
+  def child_spec(_) do
+    %{
+      id: __MODULE__,
+      start: {__MODULE__, :start_link, []}
+    }
+  end
+
+  def start_link do
+    GenServer.start_link(__MODULE__, [], name: __MODULE__)
+  end
+
+  def init(_) do
+    __MODULE__ = :ets.new(__MODULE__, [:set, :named_table, :public, read_concurrency: true])
+
+    __MODULE__.Ready =
+      :ets.new(__MODULE__.Ready, [:set, :named_table, :public, read_concurrency: true])
+
+    {:ok, nil}
+  end
+
+  def projects do
+    __MODULE__
+    |> :ets.tab2list()
+    |> Enum.map(fn {_, project} -> project end)
+  end
+
+  def add_projects(new_projects) when is_list(new_projects) do
+    for new_project <- new_projects do
+      # We use `:ets.insert_new/2` to avoid overwriting the cached project's entropy
+      :ets.insert_new(__MODULE__, {new_project.root_uri, new_project})
+    end
+  end
+
+  def remove_projects(removed_projects) when is_list(removed_projects) do
+    for removed_project <- removed_projects do
+      :ets.delete(__MODULE__, removed_project.root_uri)
+    end
+  end
+
+  def set_projects(new_projects) when is_list(new_projects) do
+    :ets.delete_all_objects(__MODULE__)
+    add_projects(new_projects)
+  end
+
+  def set_ready(%Project{} = project, ready?) when is_boolean(ready?) do
+    if ready? do
+      :ets.insert(__MODULE__.Ready, {project.root_uri, true})
+    else
+      :ets.delete(__MODULE__.Ready, project.root_uri)
+    end
+  end
+
+  def active?(%Project{} = project) do
+    case :ets.lookup(__MODULE__.Ready, project.root_uri) do
+      [{_, true}] -> true
+      _ -> false
+    end
+  end
+end

apps/expert/lib/expert/application.ex

@@ -74,6 +74,7 @@ defmodule Expert.Application do
       {GenLSP.Assigns, [name: Expert.Assigns]},
       {Task.Supervisor, name: :expert_task_queue},
       {GenLSP.Buffer, [name: Expert.Buffer] ++ buffer_opts},
+      {Expert.ActiveProjects, []},
       {Expert,
        name: Expert,
        buffer: Expert.Buffer,

apps/expert/lib/expert/configuration.ex

@@ -6,19 +6,16 @@ defmodule Expert.Configuration do
   alias Expert.Configuration.Support
   alias Expert.Dialyzer
   alias Expert.Protocol.Id
-  alias Forge.Project
   alias GenLSP.Notifications.WorkspaceDidChangeConfiguration
   alias GenLSP.Requests
   alias GenLSP.Structures
 
-  defstruct project: nil,
-            support: nil,
+  defstruct support: nil,
             client_name: nil,
             additional_watched_extensions: nil,
             dialyzer_enabled?: false
 
   @type t :: %__MODULE__{
-          project: Project.t() | nil,
           support: support | nil,
           client_name: String.t() | nil,
           additional_watched_extensions: [String.t()] | nil,
@@ -29,12 +26,11 @@ 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.ClientCapabilities.t(), String.t() | nil) :: t
+  def new(%Structures.ClientCapabilities{} = client_capabilities, client_name) do
     support = Support.new(client_capabilities)
-    project = Project.new(root_uri)
 
-    %__MODULE__{support: support, project: project, client_name: client_name}
+    %__MODULE__{support: support, client_name: client_name}
     |> tap(&set/1)
   end
 

apps/expert/lib/expert/engine_supervisor.ex

@@ -14,11 +14,15 @@ defmodule Expert.EngineSupervisor do
   end
 
   def start_link(%Project{} = project) do
-    DynamicSupervisor.start_link(__MODULE__, project, name: __MODULE__, strategy: :one_for_one)
+    DynamicSupervisor.start_link(__MODULE__, project, name: name(project), strategy: :one_for_one)
+  end
+
+  defp name(%Project{} = project) do
+    :"#{Project.name(project)}::project_node_supervisor"
   end
 
   def start_project_node(%Project{} = project) do
-    DynamicSupervisor.start_child(__MODULE__, EngineNode.child_spec(project))
+    DynamicSupervisor.start_child(name(project), EngineNode.child_spec(project))
   end
 
   @impl true

apps/expert/lib/expert/port.ex

@@ -27,7 +27,9 @@ defmodule Expert.Port do
       opts =
         opts
         |> Keyword.put_new_lazy(:cd, fn -> Project.root_path(project) end)
-        |> Keyword.put_new(:env, environment_variables)
+        |> Keyword.update(:env, environment_variables, fn old_env ->
+          old_env ++ environment_variables
+        end)
 
       open(project, elixir_executable, opts)
     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
@@ -49,7 +39,7 @@ defmodule Expert.Project.Supervisor do
     DynamicSupervisor.terminate_child(Expert.Project.DynamicSupervisor.name(), pid)
   end
 
-  defp name(%Project{} = project) do
+  def name(%Project{} = project) do
     :"#{Project.name(project)}::supervisor"
   end
 end

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

@@ -1,20 +1,24 @@
 defmodule Expert.Provider.Handlers.CodeAction do
+  alias Expert.ActiveProjects
   alias Expert.Configuration
   alias Expert.EngineApi
   alias Forge.CodeAction
+  alias Forge.Project
   alias GenLSP.Requests
   alias GenLSP.Structures
 
   def handle(
         %Requests.TextDocumentCodeAction{params: %Structures.CodeActionParams{} = params},
-        %Configuration{} = config
+        %Configuration{}
       ) do
     document = Forge.Document.Container.context_document(params, nil)
+    projects = ActiveProjects.projects()
+    project = Project.project_for_document(projects, document)
     diagnostics = Enum.map(params.context.diagnostics, &to_code_action_diagnostic/1)
 
     code_actions =
       EngineApi.code_actions(
-        config.project,
+        project,
         document,
         params.range,
         diagnostics,