cache Mix.Project data and make all accesses to it safe from Mix.State push/pop during compile

Author: lukaszsamson

apps/language_server/lib/language_server.ex

@@ -14,6 +14,7 @@ defmodule ElixirLS.LanguageServer do
         {ElixirLS.LanguageServer.JsonRpc, name: ElixirLS.LanguageServer.JsonRpc},
         {ElixirLS.LanguageServer.Providers.WorkspaceSymbols, []},
         {ElixirLS.LanguageServer.Tracer, []},
+        {ElixirLS.LanguageServer.MixProject, []},
         {ElixirLS.LanguageServer.ExUnitTestTracer, []}
       ]
       |> Enum.reject(&is_nil/1)

apps/language_server/lib/language_server/build.ex

@@ -15,6 +15,7 @@ defmodule ElixirLS.LanguageServer.Build do
 
               case reload_project() do
                 {:ok, mixfile_diagnostics} ->
+                  ElixirLS.LanguageServer.MixProject.store()
                   # FIXME: Private API
 
                   try do

apps/language_server/lib/language_server/mix_project.ex

@@ -0,0 +1,157 @@
+defmodule ElixirLS.LanguageServer.MixProject do
+  @moduledoc """
+  This module serves as a caching layer guarantying a safe access to Mix.Project functions. Note that
+  Mix.Project functions cannot be safely called during a build as dep mix projects are being pushed and
+  popped
+  """
+  use GenServer
+
+  def start_link(args) do
+    GenServer.start_link(__MODULE__, args, name: __MODULE__)
+  end
+
+  def store do
+    GenServer.call(__MODULE__, :store)
+  end
+
+  @spec get() :: module | nil
+  def get do
+    GenServer.call(__MODULE__, {:get, :get})
+  end
+
+  @spec get!() :: module
+  def get! do
+    get() || raise Mix.NoProjectError, []
+  end
+
+  @spec project_file() :: binary | nil
+  def project_file() do
+    GenServer.call(__MODULE__, {:get, :project_file})
+  end
+
+  # @doc since: "1.15.0"
+  # @spec parent_umbrella_project_file() :: binary | nil
+  # defdelegate parent_umbrella_project_file(), to: Mix.ProjectStack
+
+  @spec config() :: keyword
+  def config do
+    GenServer.call(__MODULE__, {:get, :config})
+  end
+
+  @spec config_files() :: [Path.t()]
+  def config_files do
+    GenServer.call(__MODULE__, {:get, :config_files})
+  end
+
+  @spec config_mtime() :: posix_mtime when posix_mtime: integer()
+  def config_mtime do
+    GenServer.call(__MODULE__, {:get, :config_mtime})
+  end
+
+  @spec umbrella?() :: boolean
+  def umbrella?() do
+    GenServer.call(__MODULE__, {:get, :umbrella?})
+  end
+
+  @spec apps_paths() :: %{optional(atom) => Path.t()} | nil
+  def apps_paths() do
+    GenServer.call(__MODULE__, {:get, :apps_paths})
+  end
+
+  @spec deps_path() :: Path.t()
+  def deps_path() do
+    GenServer.call(__MODULE__, {:get, :deps_path})
+  end
+
+  @spec deps_apps() :: [atom()]
+  def deps_apps() do
+    GenServer.call(__MODULE__, {:get, :deps_apps})
+  end
+
+  @spec deps_scms() :: %{optional(atom) => Mix.SCM.t()}
+  def deps_scms() do
+    GenServer.call(__MODULE__, {:get, :deps_scms})
+  end
+
+  @spec deps_paths() :: %{optional(atom) => Path.t()}
+  def deps_paths() do
+    GenServer.call(__MODULE__, {:get, :deps_paths})
+  end
+
+  # @doc since: "1.15.0"
+  # @spec deps_tree(keyword) :: %{optional(atom) => [atom]}
+  # def deps_tree(opts \\ []) when is_list(opts) do
+  #   traverse_deps(opts, fn %{deps: deps} -> Enum.map(deps, & &1.app) end)
+  # end
+
+  @spec build_path() :: Path.t()
+  def build_path() do
+    GenServer.call(__MODULE__, {:get, :build_path})
+  end
+
+  @spec manifest_path() :: Path.t()
+  def manifest_path() do
+    GenServer.call(__MODULE__, {:get, :manifest_path})
+  end
+
+  @spec app_path() :: Path.t()
+  def app_path() do
+    config = config()
+    config[:deps_app_path] ||
+      cond do
+        app = config[:app] ->
+          Path.join([build_path(), "lib", Atom.to_string(app)])
+
+        config[:apps_path] ->
+          raise "trying to access Mix.Project.app_path/1 for an umbrella project but umbrellas have no app"
+
+        true ->
+          Mix.raise(
+            "Cannot access build without an application name, " <>
+              "please ensure you are in a directory with a mix.exs file and it defines " <>
+              "an :app name under the project configuration"
+          )
+      end
+  end
+
+  @spec compile_path() :: Path.t()
+  def compile_path() do
+    Path.join(app_path(), "ebin")
+  end
+
+  @spec consolidation_path() :: Path.t()
+  def consolidation_path() do
+    GenServer.call(__MODULE__, {:get, :consolidation_path})
+  end
+
+  @impl GenServer
+  def init(_) do
+    {:ok, nil}
+  end
+
+  @impl GenServer
+  def handle_call({:get, key}, _from, state) do
+    {:reply, Map.fetch!(state, key), state}
+  end
+
+  def handle_call(:store, _from, _state) do
+    state = %{
+    get: Mix.Project.get(),
+    project_file: Mix.Project.project_file(),
+    config: Mix.Project.config(),
+    config_files: Mix.Project.config_files(),
+    config_mtime: Mix.Project.config_mtime(),
+    umbrella?: Mix.Project.umbrella?(),
+    apps_paths: Mix.Project.apps_paths(),
+    deps_path: Mix.Project.deps_path(),
+    deps_apps: Mix.Project.deps_apps(),
+    deps_scms: Mix.Project.deps_scms(),
+    deps_paths: Mix.Project.deps_paths(),
+    build_path: Mix.Project.build_path(),
+    manifest_path: Mix.Project.manifest_path(),
+    consolidation_path: Mix.Project.consolidation_path()
+    }
+
+    {:reply, :ok, state}
+  end
+end

apps/language_server/lib/language_server/mix_tasks/format.ex

@@ -253,8 +253,13 @@ defmodule Mix.Tasks.ElixirLSFormat do
       Mix.raise("--no-exit can only be used together with --check-formatted")
     end
 
+    deps_paths = Mix.Project.deps_paths()
+    manifest_path = Mix.Project.manifest_path()
+    config_mtime = Mix.Project.config_mtime()
+    mix_project = Mix.Project.get()
+
     {formatter_opts_and_subs, _sources} =
-      eval_deps_and_subdirectories(cwd, dot_formatter, formatter_opts, [dot_formatter])
+      eval_deps_and_subdirectories(cwd, mix_project, deps_paths, manifest_path, config_mtime, dot_formatter, formatter_opts, [dot_formatter])
 
     formatter_opts_and_subs = load_plugins(formatter_opts_and_subs)
 
@@ -326,10 +331,14 @@ defmodule Mix.Tasks.ElixirLSFormat do
   @doc since: "1.13.0"
   def formatter_for_file(file, opts \\ []) do
     cwd = Keyword.get_lazy(opts, :root, &File.cwd!/0)
+    deps_paths = Keyword.get_lazy(opts, :deps_paths, &Mix.Project.deps_paths/0)
+    manifest_path = Keyword.get_lazy(opts, :manifest_path, &Mix.Project.manifest_path/0)
+    config_mtime = Keyword.get_lazy(opts, :config_mtime, &Mix.Project.config_mtime/0)
+    mix_project = Keyword.get_lazy(opts, :mix_project, &Mix.Project.get/0)
     {dot_formatter, formatter_opts} = eval_dot_formatter(cwd, opts)
 
     {formatter_opts_and_subs, _sources} =
-      eval_deps_and_subdirectories(cwd, dot_formatter, formatter_opts, [dot_formatter])
+      eval_deps_and_subdirectories(cwd, mix_project, deps_paths, manifest_path, config_mtime, dot_formatter, formatter_opts, [dot_formatter])
 
     formatter_opts_and_subs = load_plugins(formatter_opts_and_subs)
 
@@ -363,7 +372,7 @@ defmodule Mix.Tasks.ElixirLSFormat do
   # This function reads exported configuration from the imported
   # dependencies and subdirectories and deals with caching the result
   # of reading such configuration in a manifest file.
-  defp eval_deps_and_subdirectories(cwd, dot_formatter, formatter_opts, sources) do
+  defp eval_deps_and_subdirectories(cwd, mix_project, deps_paths, manifest_path, config_mtime, dot_formatter, formatter_opts, sources) do
     deps = Keyword.get(formatter_opts, :import_deps, [])
     subs = Keyword.get(formatter_opts, :subdirectories, [])
 
@@ -378,12 +387,12 @@ defmodule Mix.Tasks.ElixirLSFormat do
     if deps == [] and subs == [] do
       {{formatter_opts, []}, sources}
     else
-      manifest = Path.join(Mix.Project.manifest_path(), @manifest)
+      manifest = Path.join(manifest_path, @manifest)
 
       {{locals_without_parens, subdirectories}, sources} =
-        maybe_cache_in_manifest(dot_formatter, manifest, fn ->
-          {subdirectories, sources} = eval_subs_opts(subs, cwd, sources)
-          {{eval_deps_opts(deps), subdirectories}, sources}
+        maybe_cache_in_manifest(dot_formatter, mix_project, manifest, config_mtime, fn ->
+          {subdirectories, sources} = eval_subs_opts(subs, cwd, mix_project, deps_paths, manifest_path, config_mtime, sources)
+          {{eval_deps_opts(deps, deps_paths), subdirectories}, sources}
         end)
 
       formatter_opts =
@@ -398,19 +407,19 @@ defmodule Mix.Tasks.ElixirLSFormat do
     end
   end
 
-  defp maybe_cache_in_manifest(dot_formatter, manifest, fun) do
+  defp maybe_cache_in_manifest(dot_formatter, mix_project, manifest, config_mtime, fun) do
     cond do
-      is_nil(Mix.Project.get()) or dot_formatter != ".formatter.exs" -> fun.()
-      entry = read_manifest(manifest) -> entry
+      is_nil(mix_project) or dot_formatter != ".formatter.exs" -> fun.()
+      entry = read_manifest(manifest, config_mtime) -> entry
       true -> write_manifest!(manifest, fun.())
     end
   end
 
-  defp read_manifest(manifest) do
+  defp read_manifest(manifest, config_mtime) do
     with {:ok, binary} <- File.read(manifest),
          {:ok, {@manifest_vsn, entry, sources}} <- safe_binary_to_term(binary),
          expanded_sources = Enum.flat_map(sources, &Path.wildcard(&1, match_dot: true)),
-         false <- Mix.Utils.stale?([Mix.Project.config_mtime() | expanded_sources], [manifest]) do
+         false <- Mix.Utils.stale?([config_mtime | expanded_sources], [manifest]) do
       {entry, sources}
     else
       _ -> nil
@@ -429,13 +438,11 @@ defmodule Mix.Tasks.ElixirLSFormat do
     {entry, sources}
   end
 
-  defp eval_deps_opts([]) do
+  defp eval_deps_opts([], _deps_paths) do
     []
   end
 
-  defp eval_deps_opts(deps) do
-    deps_paths = Mix.Project.deps_paths()
-
+  defp eval_deps_opts(deps, deps_paths) do
     for dep <- deps,
         dep_path = assert_valid_dep_and_fetch_path(dep, deps_paths),
         dep_dot_formatter = Path.join(dep_path, ".formatter.exs"),
@@ -446,7 +453,7 @@ defmodule Mix.Tasks.ElixirLSFormat do
         do: parenless_call
   end
 
-  defp eval_subs_opts(subs, cwd, sources) do
+  defp eval_subs_opts(subs, cwd, mix_project, deps_paths, manifest_path, config_mtime, sources) do
     {subs, sources} =
       Enum.flat_map_reduce(subs, sources, fn sub, sources ->
         cwd = Path.expand(sub, cwd)
@@ -460,7 +467,7 @@ defmodule Mix.Tasks.ElixirLSFormat do
         formatter_opts = eval_file_with_keyword_list(sub_formatter)
 
         {formatter_opts_and_subs, sources} =
-          eval_deps_and_subdirectories(sub, :in_memory, formatter_opts, sources)
+          eval_deps_and_subdirectories(sub, mix_project, deps_paths, manifest_path, config_mtime, :in_memory, formatter_opts, sources)
 
         {[{sub, formatter_opts_and_subs}], sources}
       else

apps/language_server/lib/language_server/server.ex

@@ -1127,34 +1127,38 @@ defmodule ElixirLS.LanguageServer.Server do
   end
 
   defp get_spec_code_lenses(state = %__MODULE__{}, uri, source_file) do
-    if dialyzer_enabled?(state) and !!state.settings["suggestSpecs"] do
+    if is_binary(state.project_dir) and dialyzer_enabled?(state) and !!state.settings["suggestSpecs"] do
       CodeLens.spec_code_lens(state.server_instance_id, uri, source_file.text)
     else
       {:ok, []}
     end
   end
 
   defp get_test_code_lenses(state = %__MODULE__{}, uri, source_file) do
-    get_test_code_lenses(
-      state,
-      uri,
-      source_file,
-      state.settings["enableTestLenses"] || false,
-      Mix.Project.umbrella?()
-    )
+    enabled = state.settings["enableTestLenses"] || false
+
+    if is_binary(state.project_dir) and enabled do
+      get_test_code_lenses(
+        state,
+        uri,
+        source_file,
+        ElixirLS.LanguageServer.MixProject.umbrella?()
+      )
+    else
+      {:ok, []}
+    end
   end
 
   defp get_test_code_lenses(
          state = %__MODULE__{project_dir: project_dir},
          "file:" <> _ = uri,
          source_file,
-         true = _enabled,
          true = _umbrella
        )
        when is_binary(project_dir) do
     file_path = SourceFile.Path.from_uri(uri)
 
-    Mix.Project.apps_paths()
+    ElixirLS.LanguageServer.MixProject.apps_paths()
     |> Enum.find(fn {_app, app_path} -> under_app?(file_path, project_dir, app_path) end)
     |> case do
       nil ->
@@ -1173,7 +1177,6 @@ defmodule ElixirLS.LanguageServer.Server do
          %__MODULE__{project_dir: project_dir},
          "file:" <> _ = uri,
          source_file,
-         true = _enabled,
          false = _umbrella
        )
        when is_binary(project_dir) do
@@ -1190,7 +1193,7 @@ defmodule ElixirLS.LanguageServer.Server do
     end
   end
 
-  defp get_test_code_lenses(%__MODULE__{}, _uri, _source_file, _, _), do: {:ok, []}
+  defp get_test_code_lenses(%__MODULE__{}, _uri, _source_file, _), do: {:ok, []}
 
   defp is_test_file?(file_path, state = %__MODULE__{project_dir: project_dir}, app, app_path)
        when is_binary(project_dir) do
@@ -1209,8 +1212,9 @@ defmodule ElixirLS.LanguageServer.Server do
   end
 
   defp is_test_file?(file_path) do
-    test_paths = Mix.Project.config()[:test_paths] || ["test"]
-    test_pattern = Mix.Project.config()[:test_pattern] || "*_test.exs"
+    config = ElixirLS.LanguageServer.MixProject.config()
+    test_paths = config[:test_paths] || ["test"]
+    test_pattern = config[:test_pattern] || "*_test.exs"
     file_path = Path.expand(file_path)
 
     Mix.Utils.extract_files(test_paths, test_pattern)

apps/language_server/lib/language_server/source_file.ex

@@ -230,17 +230,19 @@ defmodule ElixirLS.LanguageServer.SourceFile do
   end
 
   @spec formatter_for(String.t(), String.t() | nil) :: {:ok, {function | nil, keyword(), String.t}} | :error
-  def formatter_for(uri = "file:" <> _, project_dir) do
+  def formatter_for(uri = "file:" <> _, project_dir) when is_binary(project_dir) do
     path = __MODULE__.Path.from_uri(uri)
 
     try do
-      true = Code.ensure_loaded?(Mix.Tasks.ElixirLSFormat)
-
-      if project_dir do
-        {:ok, Mix.Tasks.ElixirLSFormat.formatter_for_file(path, root: project_dir)}
-      else
-        {:ok, Mix.Tasks.ElixirLSFormat.formatter_for_file(path)}
-      end
+      alias ElixirLS.LanguageServer.MixProject
+      opts = [
+      deps_paths: MixProject.deps_paths(),
+      manifest_path: MixProject.manifest_path(),
+      config_mtime: MixProject.config_mtime(),
+      mix_project: MixProject.get(),
+      root: project_dir
+      ]
+      {:ok, Mix.Tasks.ElixirLSFormat.formatter_for_file(path, opts)}
     catch
       kind, payload ->
         {payload, stacktrace} = Exception.blame(kind, payload, __STACKTRACE__)