Perform more loading on the client if possible

Author: josevalim

lib/elixir/lib/kernel/parallel_compiler.ex

@@ -441,10 +441,10 @@ defmodule Kernel.ParallelCompiler do
         :erlang.put(:elixir_compiler_file, file)
 
         try do
-          case output do
-            {:compile, _} -> compile_file(file, dest, false, parent)
-            :compile -> compile_file(file, dest, true, parent)
-            :require -> require_file(file, parent)
+          if output == :require do
+            require_file(file, parent)
+          else
+            compile_file(file, dest, parent)
           end
         catch
           kind, reason ->
@@ -549,9 +549,9 @@ defmodule Kernel.ParallelCompiler do
     wait_for_messages([], spawned, waiting, files, result, warnings, errors, state)
   end
 
-  defp compile_file(file, path, force_load?, parent) do
+  defp compile_file(file, path, parent) do
     :erlang.process_flag(:error_handler, Kernel.ErrorHandler)
-    :erlang.put(:elixir_compiler_dest, {path, force_load?})
+    :erlang.put(:elixir_compiler_dest, path)
     :elixir_compiler.file(file, &each_file(&1, &2, parent))
   end
 
@@ -652,6 +652,18 @@ 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_available, child, ref, file, module, binary, loaded?} ->
         state.each_module.(file, module, binary)
 

lib/elixir/src/elixir_module.erl

@@ -159,7 +159,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, Forceload} = beam_location(ModuleAsCharlist),
+    BeamLocation = beam_location(ModuleAsCharlist),
 
     {Binary, PersistedAttributes, Autoload} =
       elixir_erl_compiler:spawn(fun() ->
@@ -219,7 +219,7 @@ compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, E) ->
 
         compile_error_if_tainted(DataSet, E),
         Binary = elixir_erl:compile(ModuleMap),
-        Autoload = Forceload or proplists:get_value(autoload, CompileOpts, false),
+        Autoload = proplists:get_value(autoload, CompileOpts, false) or load_module(Module),
         spawn_parallel_checker(CheckerInfo, Module, ModuleMap, BeamLocation),
         {Binary, PersistedAttributes, Autoload}
       end),
@@ -550,12 +550,10 @@ bag_lookup_element(Table, Name, Pos) ->
 
 beam_location(ModuleAsCharlist) ->
   case get(elixir_compiler_dest) of
-    {Dest, ForceLoad} when is_binary(Dest) ->
-      BeamLocation =
-        filename:join(elixir_utils:characters_to_list(Dest), ModuleAsCharlist ++ ".beam"),
-      {BeamLocation, ForceLoad};
+    Dest when is_binary(Dest) ->
+      filename:join(elixir_utils:characters_to_list(Dest), ModuleAsCharlist ++ ".beam");
     _ ->
-      {"", true}
+      ""
   end.
 
 %% Integration with elixir_compiler that makes the module available
@@ -593,6 +591,16 @@ 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