Do not block module process for loading

Author: josevalim

lib/elixir/lib/kernel/parallel_compiler.ex

@@ -422,10 +422,10 @@ defmodule Kernel.ParallelCompiler do
         :erlang.put(:elixir_compiler_file, file)
 
         try do
-          if output == :require do
-            require_file(file, parent)
-          else
-            compile_file(file, dest, parent)
+          case output do
+            {:compile, _} -> compile_file(file, dest, false, parent)
+            :compile -> compile_file(file, dest, true, parent)
+            :require -> require_file(file, parent)
           end
         catch
           kind, reason ->
@@ -530,9 +530,9 @@ defmodule Kernel.ParallelCompiler do
     wait_for_messages([], spawned, waiting, files, result, warnings, errors, state)
   end
 
-  defp compile_file(file, path, parent) do
+  defp compile_file(file, path, force_load?, parent) do
     :erlang.process_flag(:error_handler, Kernel.ErrorHandler)
-    :erlang.put(:elixir_compiler_dest, path)
+    :erlang.put(:elixir_compiler_dest, {path, force_load?})
     :elixir_compiler.file(file, &each_file(&1, &2, parent))
   end
 
@@ -633,18 +633,6 @@ defmodule Kernel.ParallelCompiler do
           state
         )
 
-      {:load_module?, child, ref, module} ->
-        # If compiling files to disk, we only load the module
-        # if other modules are waiting for it.
-        load? =
-          case state.output do
-            {:compile, _} -> match?(%{{:module, ^module} => [_ | _]}, result)
-            _ -> true
-          end
-
-        send(child, {ref, load?})
-        spawn_workers(queue, spawned, waiting, files, result, warnings, errors, state)
-
       {{:module_loaded, module}, _ref, _type, _pid, _reason} ->
         result =
           Map.update!(result, {:module, module}, fn {binary, _loader} -> {binary, true} end)

lib/elixir/src/elixir_module.erl

@@ -155,7 +155,7 @@ compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, E) ->
     put_compiler_modules([Module | CompilerModules]),
     {Result, ModuleE, CallbackE} = eval_form(Line, Module, DataBag, Block, Vars, Prune, E),
     CheckerInfo = checker_info(),
-    BeamLocation = beam_location(ModuleAsCharlist),
+    {BeamLocation, Forceload} = beam_location(ModuleAsCharlist),
 
     {Binary, PersistedAttributes, Autoload} =
       elixir_erl_compiler:spawn(fun() ->
@@ -215,7 +215,7 @@ compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, E) ->
 
         compile_error_if_tainted(DataSet, E),
         Binary = elixir_erl:compile(ModuleMap),
-        Autoload = proplists:get_value(autoload, CompileOpts, false) or load_module(Module),
+        Autoload = Forceload or proplists:get_value(autoload, CompileOpts, false),
         spawn_parallel_checker(CheckerInfo, Module, ModuleMap),
         {Binary, PersistedAttributes, Autoload}
       end),
@@ -544,10 +544,11 @@ bag_lookup_element(Table, Name, Pos) ->
 
 beam_location(ModuleAsCharlist) ->
   case get(elixir_compiler_dest) of
-    Dest when is_binary(Dest) ->
-      filename:join(elixir_utils:characters_to_list(Dest), ModuleAsCharlist ++ ".beam");
+    {Dest, Forceload} when is_binary(Dest) ->
+      {filename:join(elixir_utils:characters_to_list(Dest), ModuleAsCharlist ++ ".beam"),
+       Forceload};
     _ ->
-      ""
+      {"", true}
   end.
 
 %% Integration with elixir_compiler that makes the module available
@@ -585,16 +586,6 @@ make_module_available(Module, Binary, Loaded) ->
       receive {Ref, ack} -> ok end
   end.
 
-load_module(Module) ->
-  case get(elixir_compiler_info) of
-    undefined ->
-      true;
-    {PID, _} ->
-      Ref = make_ref(),
-      PID ! {'load_module?', self(), Ref, Module},
-      receive {Ref, Boolean} -> Boolean end
-  end.
-
 %% Error handling and helpers.
 
 %% We've reached the elixir_module or eval internals, skip it with the rest