Speed up the update_stale function.

Author: hworld

apps/language_server/lib/language_server/dialyzer.ex

@@ -223,7 +223,7 @@ defmodule ElixirLS.LanguageServer.Dialyzer do
   defp trigger_analyze(state), do: state
 
   defp update_stale(md5, removed_files, file_changes, timestamp) do
-    prev_paths = MapSet.new(Map.keys(md5))
+    prev_paths = Map.keys(md5) |> MapSet.new()
 
     # FIXME: Private API
     all_paths =
@@ -241,19 +241,32 @@ defmodule ElixirLS.LanguageServer.Dialyzer do
       |> MapSet.difference(prev_paths)
       |> MapSet.to_list()
 
-    # FIXME: Private API
-    changed = Enum.uniq(new_paths ++ Mix.Utils.extract_stale(all_paths, [timestamp]))
-
-    changed_contents =
-      Task.async_stream(
-        changed,
-        fn file ->
-          content = File.read!(file)
-          {file, content, module_md5(file)}
-        end,
-        timeout: :infinity
-      )
-      |> Enum.into([])
+    {us, {changed, changed_contents}} =
+      :timer.tc(fn ->
+        changed =
+          all_paths
+          |> extract_stale(timestamp)
+          |> Enum.concat(new_paths)
+          |> Enum.uniq()
+
+        changed_contents =
+          Task.async_stream(
+            changed,
+            fn file ->
+              content = File.read!(file)
+              {file, content, module_md5(file)}
+            end,
+            timeout: :infinity
+          )
+          |> Enum.into([])
+
+        {changed, changed_contents}
+      end)
+
+    JsonRpc.log_message(
+      :info,
+      "[ElixirLS Dialyzer] Found #{length(changed)} changed files in #{div(us, 1000)} milliseconds"
+    )
 
     file_changes =
       Enum.reduce(changed_contents, file_changes, fn {:ok, {file, content, hash}}, file_changes ->
@@ -269,6 +282,23 @@ defmodule ElixirLS.LanguageServer.Dialyzer do
     {removed_files, file_changes}
   end
 
+  defp extract_stale(sources, timestamp) do
+    for source <- sources,
+        last_modified(source) > timestamp do
+      source
+    end
+  end
+
+  defp last_modified(path) do
+    case File.stat(path) do
+      {:ok, %File.Stat{mtime: mtime}} ->
+        mtime
+
+      {:error, _} ->
+        {0, 0}
+    end
+  end
+
   defp temp_file_path(root_path, file) do
     Path.join([root_path, ".elixir_ls/dialyzer_tmp", file])
   end

apps/language_server/test/dialyzer_test.exs

@@ -92,6 +92,53 @@ defmodule ElixirLS.LanguageServer.DialyzerTest do
     end)
   end
 
+  test "only analyzes the changed files", %{server: server} do
+    in_fixture(__DIR__, "dialyzer", fn ->
+      file_c = SourceFile.path_to_uri(Path.absname("lib/c.ex"))
+
+      capture_log(fn ->
+        root_uri = SourceFile.path_to_uri(File.cwd!())
+        Server.receive_packet(server, initialize_req(1, root_uri, %{}))
+
+        Server.receive_packet(
+          server,
+          did_change_configuration(%{
+            "elixirLS" => %{"dialyzerEnabled" => true, "dialyzerFormat" => "dialyxir_long"}
+          })
+        )
+
+        assert_receive %{"method" => "textDocument/publishDiagnostics"}, 20_000
+
+        c_text = """
+        defmodule C do
+        end
+        """
+
+        c_uri = SourceFile.path_to_uri("lib/c.ex")
+
+        # The dialyzer process checks a second back since mtime only has second
+        # granularity, so we need to trigger one save that will set the
+        # timestamp, and then wait a second and save again to get the actual
+        # changed file.
+        for _ <- 1..2 do
+          Server.receive_packet(server, did_open(c_uri, "elixir", 1, c_text))
+          File.write!("lib/c.ex", c_text)
+          Server.receive_packet(server, did_save(c_uri))
+          assert_receive publish_diagnostics_notif(^file_c, []), 20_000
+
+          Process.sleep(1_500)
+        end
+
+        assert_receive notification("window/logMessage", %{
+                         "message" => "[ElixirLS Dialyzer] Found 1 changed files" <> _
+                       })
+
+        # Stop while we're still capturing logs to avoid log leakage
+        GenServer.stop(server)
+      end)
+    end)
+  end
+
   test "reports dialyxir_long formatted error", %{server: server} do
     in_fixture(__DIR__, "dialyzer", fn ->
       file_a = SourceFile.path_to_uri(Path.absname("lib/a.ex"))