More fixes

Author: josevalim

lib/elixir/lib/kernel/parallel_compiler.ex

@@ -139,6 +139,8 @@ defmodule Kernel.ParallelCompiler do
       * `{:runtime, modules, warnings}` - to stop compilation and verify the list
         of modules because dependent modules have changed
 
+    * `:after_persistence` - ...
+
     * `:long_compilation_threshold` - the timeout (in seconds) to check for modules
       taking too long to compile. For each file that exceeds the threshold, the
       `:each_long_compilation` callback is invoked. From Elixir v1.11, only the time
@@ -258,13 +260,6 @@ defmodule Kernel.ParallelCompiler do
     {status, modules_or_errors, info} =
       try do
         spawn_workers(schedulers, cache, files, output, options)
-      else
-        {:ok, outcome, info} ->
-          beam_timestamp = Keyword.get(options, :beam_timestamp)
-          {:ok, write_module_binaries(outcome, output, beam_timestamp), info}
-
-        {:error, errors, info} ->
-          {:error, errors, info}
       after
         Module.ParallelChecker.stop(cache)
       end
@@ -288,7 +283,9 @@ defmodule Kernel.ParallelCompiler do
 
     {outcome, state} =
       spawn_workers(files, %{}, %{}, [], %{}, [], [], %{
+        beam_timestamp: Keyword.get(options, :beam_timestamp),
         dest: Keyword.get(options, :dest),
+        after_persistence: Keyword.get(options, :after_persistence, fn -> :ok end),
         each_cycle: Keyword.get(options, :each_cycle, fn -> {:runtime, [], []} end),
         each_file: Keyword.get(options, :each_file, fn _, _ -> :ok end) |> each_file(),
         each_long_compilation: Keyword.get(options, :each_long_compilation, fn _file -> :ok end),
@@ -345,9 +342,11 @@ defmodule Kernel.ParallelCompiler do
   ## Verification
 
   defp verify_modules(result, compile_warnings, dependent_modules, state) do
+    modules = write_module_binaries(result, state.output, state.beam_timestamp)
+    _ = state.after_persistence.()
     runtime_warnings = maybe_check_modules(result, dependent_modules, state)
     info = %{compile_warnings: Enum.reverse(compile_warnings), runtime_warnings: runtime_warnings}
-    {{:ok, result, info}, state}
+    {{:ok, modules, info}, state}
   end
 
   defp maybe_check_modules(result, runtime_modules, state) do

lib/mix/lib/mix/compilers/elixir.ex

@@ -1026,8 +1026,11 @@ defmodule Mix.Compilers.Elixir do
     pid =
       spawn_link(fn ->
         compile_opts = [
+          after_persistence: fn ->
+            compiler_call(parent, ref, {:after_persistence, opts})
+          end,
           each_cycle: fn ->
-            compiler_call(parent, ref, {:each_cycle, stale_modules, dest, timestamp, opts})
+            compiler_call(parent, ref, {:each_cycle, stale_modules, dest, timestamp})
           end,
           each_file: fn file, lexical ->
             compiler_call(parent, ref, {:each_file, file, lexical, verbose})
@@ -1063,8 +1066,13 @@ defmodule Mix.Compilers.Elixir do
 
   defp compiler_loop(ref, pid, state, cwd) do
     receive do
-      {^ref, {:each_cycle, stale_modules, dest, timestamp, opts}} ->
-        {response, state} = each_cycle(stale_modules, dest, timestamp, state, opts)
+      {^ref, {:after_persistence, opts}} ->
+        {response, state} = after_persistence(state, opts)
+        send(pid, {ref, response})
+        compiler_loop(ref, pid, state, cwd)
+
+      {^ref, {:each_cycle, stale_modules, dest, timestamp}} ->
+        {response, state} = each_cycle(stale_modules, dest, timestamp, state)
         send(pid, {ref, response})
         compiler_loop(ref, pid, state, cwd)
 
@@ -1092,7 +1100,17 @@ defmodule Mix.Compilers.Elixir do
     end
   end
 
-  defp each_cycle(stale_modules, compile_path, timestamp, state, opts) do
+  defp after_persistence(state, opts) do
+    {modules, exports, sources, changed, pending_modules, stale_exports, consolidation} = state
+
+    state =
+      {modules, exports, sources, changed, pending_modules, stale_exports,
+       maybe_consolidate(consolidation, modules, opts)}
+
+    {:ok, state}
+  end
+
+  defp each_cycle(stale_modules, compile_path, timestamp, state) do
     {modules, _exports, sources, changed, pending_modules, stale_exports, consolidation} = state
 
     {pending_modules, exports, changed} =
@@ -1136,8 +1154,7 @@ defmodule Mix.Compilers.Elixir do
       runtime_paths =
         Enum.map(runtime_modules, &{&1, Path.join(compile_path, Atom.to_string(&1) <> ".beam")})
 
-      protocols_and_impls = maybe_consolidate(consolidation, modules, opts)
-      state = {modules, exports, sources, [], pending_modules, stale_exports, protocols_and_impls}
+      state = {modules, exports, sources, [], pending_modules, stale_exports, consolidation}
       {{:runtime, runtime_paths, []}, state}
     else
       Mix.Utils.compiling_n(length(changed), :ex)