Type checked struct operations must not deadlock the compiler

Author: josevalim

lib/elixir/src/elixir_map.erl

@@ -126,7 +126,7 @@ validate_struct(Atom, _) when is_atom(Atom) -> true;
 validate_struct(_, _) -> false.
 
 assert_struct_info_if_not_function(Meta, Name, Assocs, #{function := nil} = E) ->
-  case maybe_load_struct_info(Meta, Name, E) of
+  case maybe_load_struct_info(Meta, Name, hard, E) of
     {ok, Info} ->
       [lists:any(fun(Field) -> ?key(Field, field) =:= Key end, Info) orelse
          function_error(Meta, E, ?MODULE, {unknown_key_for_struct, Name, Key})
@@ -140,12 +140,24 @@ assert_struct_info_if_not_function(_Meta, _Name, _Assocs, _E) ->
   ok.
 
 maybe_load_struct_info(Meta, Name, E) ->
+  maybe_load_struct_info(Meta, Name, soft, E).
+
+maybe_load_struct_info(Meta, Name, Mode, E) ->
   try
-    case is_open(Name, Meta, E) andalso lookup_struct_info_from_data_tables(Name) of
+    InContext = in_context(Name, E),
+
+    case (InContext orelse is_compiling_struct(Meta, Name, Mode, E))
+           andalso lookup_struct_info_from_data_tables(Name) of
       %% If I am accessing myself and there is no attribute,
       %% don't invoke the fallback to avoid calling loaded code.
       false when ?key(E, module) =:= Name -> nil;
-      false -> Name:'__info__'(struct);
+      false ->
+        %% We already attempted to wait for the struct (unless InContext),
+        %% so we only invoke '__info__' if already loaded or InContext
+        case InContext orelse erlang:module_loaded(Name) of
+          true -> Name:'__info__'(struct);
+          false -> nil
+        end;
       InfoList -> InfoList
     end
   of
@@ -165,7 +177,8 @@ lookup_struct_info_from_data_tables(Module) ->
 
 load_struct(Meta, Name, Assocs, E) ->
   try
-    case is_open(Name, Meta, E) andalso elixir_def:external_for(Meta, Name, '__struct__', 1, [def]) of
+    case (in_context(Name, E) orelse is_compiling_struct(Meta, Name, hard, E)) andalso
+           elixir_def:external_for(Meta, Name, '__struct__', 1, [def]) of
       %% If I am accessing myself and there is no __struct__ function,
       %% don't invoke the fallback to avoid calling loaded code.
       false when ?key(E, module) =:= Name ->
@@ -221,17 +234,17 @@ assert_and_trace_struct_assocs(Meta, Name, Assocs, E) ->
   elixir_env:trace({struct_expansion, Meta, Name, Keys}, E),
   Keys.
 
-is_open(Name, Meta, E) ->
-  in_context(Name, E) orelse ((code:ensure_loaded(Name) /= {module, Name}) andalso wait_for_struct(Name, Meta, E)).
+is_compiling_struct(Meta, Name, Mode, E) ->
+  (code:ensure_loaded(Name) /= {module, Name}) andalso wait_for_struct(Meta, Name, Mode, E).
 
 in_context(Name, E) ->
   %% We also include the current module because it won't be present
   %% in context module in case the module name is defined dynamically.
   lists:member(Name, [?key(E, module) | ?key(E, context_modules)]).
 
-wait_for_struct(Module, Meta, E) ->
+wait_for_struct(Meta, Module, Mode, E) ->
   (erlang:get(elixir_compiler_info) /= undefined) andalso
-    ('Elixir.Kernel.ErrorHandler':ensure_compiled(Module, struct, hard, elixir_utils:get_line(Meta, E)) =:= found).
+    ('Elixir.Kernel.ErrorHandler':ensure_compiled(Module, struct, Mode, elixir_utils:get_line(Meta, E)) =:= found).
 
 struct_undef(Name, E) ->
   case in_context(Name, E) andalso (?key(E, function) == nil) of

lib/elixir/src/elixir_module.erl

@@ -159,13 +159,19 @@ compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, E) ->
   {DataSet, DataBag} = Tables,
 
   try
+    CompilerInfo = erlang:get(elixir_compiler_info),
     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),
 
     {Binary, PersistedAttributes, Autoload} =
       elixir_erl_compiler:spawn(fun() ->
+        case CompilerInfo of
+          undefined -> undefined;
+          _ -> erlang:put(elixir_compiler_info, CompilerInfo)
+        end,
+
         PersistedAttributes = ets:lookup_element(DataBag, persisted_attributes, 2),
         Attributes = attributes(DataSet, DataBag, PersistedAttributes),
         AllDefinitions = elixir_def:fetch_definitions(Module, E),
@@ -574,7 +580,7 @@ bag_lookup_element(Table, Name, Pos) ->
   end.
 
 beam_location(ModuleAsCharlist) ->
-  case get(elixir_compiler_dest) of
+  case erlang:get(elixir_compiler_dest) of
     {Dest, Forceload} when is_binary(Dest) ->
       {filename:join(elixir_utils:characters_to_list(Dest), ModuleAsCharlist ++ ".beam"),
        Forceload};
@@ -585,7 +591,7 @@ beam_location(ModuleAsCharlist) ->
 %% Integration with elixir_compiler that makes the module available
 
 checker_info() ->
-  case get(elixir_checker_info) of
+  case erlang:get(elixir_checker_info) of
     undefined -> {self(), nil};
     _ -> 'Elixir.Module.ParallelChecker':get()
   end.
@@ -601,19 +607,19 @@ spawn_parallel_checker(CheckerInfo, Module, ModuleMap, Signatures, BeamLocation)
   'Elixir.Module.ParallelChecker':spawn(CheckerInfo, Module, ModuleMap, Signatures, BeamLocation, Log).
 
 make_module_available(Module, Binary, Loaded) ->
-  case get(elixir_module_binaries) of
+  case erlang:get(elixir_module_binaries) of
     Current when is_list(Current) ->
       put(elixir_module_binaries, [{Module, Binary} | Current]);
     _ ->
       ok
   end,
 
-  case get(elixir_compiler_info) of
+  case erlang:get(elixir_compiler_info) of
     undefined ->
       ok;
     {PID, _} ->
       Ref = make_ref(),
-      PID ! {module_available, self(), Ref, get(elixir_compiler_file), Module, Binary, Loaded},
+      PID ! {module_available, self(), Ref, erlang:get(elixir_compiler_file), Module, Binary, Loaded},
       receive {Ref, ack} -> ok end
   end.