avoid Code.ensure_compiled as it is prone to locking

Author: lukaszsamson

apps/elixir_ls_utils/lib/completion_engine.ex

@@ -1044,7 +1044,7 @@ defmodule ElixirLS.Utils.CompletionEngine do
         metadata.mods_funs_to_positions |> Map.has_key?({mod, nil, nil}) ->
           get_metadata_module_funs(mod, include_builtin, env, metadata, cursor_position)
 
-        match?({:module, _}, ensure_loaded(mod)) ->
+        ensure_loaded?(mod) ->
           get_module_funs(mod, include_builtin)
 
         true ->
@@ -1380,8 +1380,8 @@ defmodule ElixirLS.Utils.CompletionEngine do
         do: {{fun_name, new_arity}, arity}
   end
 
-  defp ensure_loaded(Elixir), do: {:error, :nofile}
-  defp ensure_loaded(mod), do: Code.ensure_compiled(mod)
+  defp ensure_loaded?(Elixir), do: false
+  defp ensure_loaded?(mod), do: Code.ensure_loaded?(mod)
 
   defp get_struct_info({:atom, module}, metadata) when is_atom(module) do
     case metadata.structs[module] do

apps/language_server/lib/language_server/providers/execute_command/llm_type_info.ex

@@ -49,29 +49,25 @@ defmodule ElixirLS.LanguageServer.Providers.ExecuteCommand.LlmTypeInfo do
   end
 
   defp extract_type_info_for_symbol(:module, module, state) do
-    case Code.ensure_compiled(module) do
-      {:module, actual_module} ->
-        type_info = extract_type_info(actual_module, state)
-        {:ok, type_info}
-
-      {:error, reason} ->
-        {:error, "Module not found or not compiled: #{inspect(reason)}"}
+    if Code.ensure_loaded?(module) do
+      type_info = extract_type_info(module, state)
+      {:ok, type_info}
+    else
+      {:error, "Module not found or not compiled"}
     end
   end
 
   defp extract_type_info_for_symbol(:remote_call, {module, function, arity}, state) do
-    case Code.ensure_compiled(module) do
-      {:module, actual_module} ->
-        # Extract all type info from the module (same as for :module case)
-        # then filter to only include the relevant function
-        full_type_info = extract_type_info(actual_module, state)
-
-        # Filter the results to only include the specific function/type/callback
-        filtered_type_info = filter_type_info_by_function(full_type_info, function, arity)
-        {:ok, filtered_type_info}
-
-      {:error, reason} ->
-        {:error, "Module not found or not compiled: #{inspect(reason)}"}
+    if Code.ensure_loaded?(module) do
+      # Extract all type info from the module (same as for :module case)
+      # then filter to only include the relevant function
+      full_type_info = extract_type_info(module, state)
+
+      # Filter the results to only include the specific function/type/callback
+      filtered_type_info = filter_type_info_by_function(full_type_info, function, arity)
+      {:ok, filtered_type_info}
+    else
+      {:error, "Module not found or not compiled"}
     end
   end
 

apps/language_server/lib/language_server/providers/plugins/module_store.ex

@@ -86,13 +86,7 @@ defmodule ElixirLS.LanguageServer.Plugins.ModuleStore do
   defp all_loaded do
     Applications.get_modules_from_applications()
     |> Enum.filter(fn module ->
-      try do
-        _ = Code.ensure_compiled(module)
-        function_exported?(module, :module_info, 0)
-      rescue
-        _ ->
-          false
-      end
+      function_exported?(module, :module_info, 0)
     end)
   end