Keep the full list of modules being defined

Author: José Valim

lib/elixir/lib/kernel/error_handler.ex

@@ -27,18 +27,11 @@ defmodule Kernel.ErrorHandler do
   def ensure_compiled(module, kind) do
     parent = :erlang.get(:elixir_compiler_pid)
     ref    = :erlang.make_ref
-    send parent, {:waiting, kind, self(), ref, module, current_module()}
+    send parent, {:waiting, kind, self(), ref, module, :elixir_module.compiler_modules()}
     :erlang.garbage_collect(self)
     receive do
       {^ref, :found}     -> true
       {^ref, :not_found} -> false
     end
   end
-
-  defp current_module do
-    case :erlang.get(:elixir_compiler_module) do
-      :undefined -> nil
-      other -> other
-    end
-  end
 end

lib/elixir/lib/kernel/parallel_compiler.ex

@@ -137,7 +137,7 @@ defmodule Kernel.ParallelCompiler do
   # Queued x, waiting for x: POSSIBLE ERROR! Release processes so we get the failures
   defp spawn_compilers(%{entries: [], waiting: waiting, queued: queued} = state) when length(waiting) == length(queued) do
     entries = for {pid, _, _, _} <- queued,
-                  waiting_on_is_not_being_defined?(waiting, pid),
+                  not waiting_on_is_being_defined?(waiting, pid),
                   do: {pid, :not_found}
 
     case entries do
@@ -151,9 +151,9 @@ defmodule Kernel.ParallelCompiler do
     wait_for_messages(state)
   end
 
-  defp waiting_on_is_not_being_defined?(waiting, pid) do
+  defp waiting_on_is_being_defined?(waiting, pid) do
     {_kind, ^pid, _, on, _defining} = List.keyfind(waiting, pid, 1)
-    List.keyfind(waiting, on, 4) == nil
+    Enum.any?(waiting, fn {_, _, _, _, defining} -> on in defining end)
   end
 
   # Wait for messages from child processes

lib/elixir/src/elixir_module.erl

@@ -1,6 +1,7 @@
 -module(elixir_module).
 -export([data_table/1, defs_table/1, is_open/1, get_attribute/2, delete_doc/6,
-         compile/4, expand_callback/6, add_beam_chunk/3, format_error/1]).
+         compile/4, expand_callback/6, add_beam_chunk/3, format_error/1,
+         compiler_modules/0]).
 -include("elixir.hrl").
 
 -define(acc_attr, {elixir, acc_attributes}).
@@ -9,6 +10,19 @@
 -define(overridable_attr, {elixir, overridable}).
 -define(location_attr, {elixir, location}).
 
+%% Stores modules currently being defined by the compiler
+
+compiler_modules() ->
+  case erlang:get(elixir_compiler_modules) of
+    undefined -> [];
+    M when is_list(M) -> M
+  end.
+
+put_compiler_modules([]) ->
+  erlang:erase(elixir_compiler_modules);
+put_compiler_modules(M) when is_list(M) ->
+  erlang:put(elixir_compiler_modules, M).
+
 %% TABLE METHODS
 
 data_table(Module) ->
@@ -59,11 +73,12 @@ do_compile(Line, Module, Block, Vars, E) ->
   File = ?m(E, file),
   check_module_availability(Line, File, Module),
 
+  CompilerModules = compiler_modules(),
   Docs = elixir_compiler:get_opt(docs),
   {Data, Defs, Ref} = build(Line, File, Module, Docs, ?m(E, lexical_tracker)),
 
   try
-    erlang:put(elixir_compiler_module, Module),
+    put_compiler_modules([Module|CompilerModules]),
     {Result, NE} = eval_form(Line, Module, Data, Block, Vars, E),
 
     _ = case ets:lookup(Data, 'on_load') of
@@ -108,7 +123,7 @@ do_compile(Line, Module, Block, Vars, E) ->
           erlang:raise(error, undef, Stack)
       end
   after
-    erlang:erase(elixir_compiler_module),
+    put_compiler_modules(CompilerModules),
     elixir_locals:cleanup(Module),
     ets:delete(Data),
     ets:delete(Defs),