Clean up

Author: josevalim

lib/elixir/lib/module/parallel_checker.ex

@@ -47,20 +47,9 @@ defmodule Module.ParallelChecker do
   @doc """
   Spawns a process that runs the parallel checker.
   """
-  def spawn(pid_checker, module_map, log?, private, used, env) do
-    %{module: module, definitions: definitions, file: file} = module_map
-
-    {signatures, unreachable} =
-      Module.Types.infer(module, file, definitions, private, used, env)
-
-    module_map = %{module_map | signatures: signatures, unreachable: unreachable}
-
-    with {pid, checker} <- pid_checker do
-      ets = :gen_server.call(checker, :ets, :infinity)
-      inner_spawn(pid, checker, module, cache_from_module_map(ets, module_map), log?)
-    end
-
-    module_map
+  def spawn({pid, checker}, module, module_map, log?) do
+    ets = :gen_server.call(checker, :ets, :infinity)
+    inner_spawn(pid, checker, module, cache_from_module_map(ets, module_map), log?)
   end
 
   defp inner_spawn(pid, checker, module, info, log?) do

lib/elixir/lib/module/types.ex

@@ -1,8 +1,6 @@
 defmodule Module.Types do
   @moduledoc false
-
   alias Module.Types.{Descr, Expr, Pattern, Helpers}
-  # TODO: Consider passing inferred types from infer into warnings
 
   # These functions are not inferred because they are added/managed by the compiler
   @no_infer [__protocol__: 1, behaviour_info: 1]

lib/elixir/src/elixir_module.erl

@@ -171,21 +171,31 @@ compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, E) ->
         NifsAttribute = lists:keyfind(nifs, 1, Attributes),
         validate_nifs_attribute(NifsAttribute, AllDefinitions, Line, E),
         elixir_import:ensure_no_local_conflict(Module, AllDefinitions, E),
-
         make_readonly(Module),
 
         (not elixir_config:is_bootstrap()) andalso
          'Elixir.Module':'__check_attributes__'(E, DataSet, DataBag),
 
-        RawCompileOpts = bag_lookup_element(DataBag, {accumulate, compile}, 2),
-        CompileOpts = validate_compile_opts(RawCompileOpts, AllDefinitions, Line, E),
-        Impls = bag_lookup_element(DataBag, impls, 2),
-
         AfterVerify = bag_lookup_element(DataBag, {accumulate, after_verify}, 2),
         [elixir_env:trace({remote_function, [], VerifyMod, VerifyFun, 1}, CallbackE) ||
          {VerifyMod, VerifyFun} <- AfterVerify],
 
-        PartialModuleMap = #{
+        %% Ensure there are no errors before we infer types
+        compile_error_if_tainted(DataSet, E),
+
+        {Signatures, Unreachable} =
+          case elixir_config:is_bootstrap() of
+            true -> {#{}, []};
+            false ->
+              Used = bag_lookup_element(DataBag, macro_private_calls, 2),
+              'Elixir.Module.Types':infer(Module, File, AllDefinitions, NewPrivate, Used, E)
+          end,
+
+        RawCompileOpts = bag_lookup_element(DataBag, {accumulate, compile}, 2),
+        CompileOpts = validate_compile_opts(RawCompileOpts, AllDefinitions, Unreachable, Line, E),
+        Impls = bag_lookup_element(DataBag, impls, 2),
+
+        ModuleMap = #{
           struct => get_struct(DataSet),
           module => Module,
           anno => Anno,
@@ -198,17 +208,14 @@ compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, E) ->
           deprecated => get_deprecated(DataBag),
           defines_behaviour => defines_behaviour(DataBag),
           impls => Impls,
-          unreachable => [],
-          signatures => #{}
+          unreachable => Unreachable,
+          signatures => Signatures
         },
 
-        %% Compute signatures only if the module is valid.
-        compile_error_if_tainted(DataSet, E),
-        ModuleMap = spawn_parallel_checker(DataBag, CheckerInfo, PartialModuleMap, NewPrivate, E),
         compile_error_if_tainted(DataSet, E),
-
         Binary = elixir_erl:compile(ModuleMap),
         Autoload = proplists:get_value(autoload, CompileOpts, true),
+        spawn_parallel_checker(CheckerInfo, Module, ModuleMap),
         {Binary, PersistedAttributes, Autoload}
       end),
 
@@ -218,7 +225,7 @@ compile(Meta, Module, ModuleAsCharlist, Block, Vars, Prune, E) ->
     elixir_env:trace({on_module, Binary, none}, ModuleE),
     warn_unused_attributes(DataSet, DataBag, PersistedAttributes, E),
     make_module_available(Module, Binary),
-    (CheckerInfo == nil) andalso
+    (CheckerInfo == undefined) andalso
       [VerifyMod:VerifyFun(Module) ||
        {VerifyMod, VerifyFun} <- bag_lookup_element(DataBag, {accumulate, after_verify}, 2)],
     {module, Module, Binary, Result}
@@ -245,27 +252,41 @@ compile_error_if_tainted(DataSet, E) ->
     false -> ok
   end.
 
-validate_compile_opts(Opts, Defs, Line, E) ->
-  lists:flatmap(fun (Opt) -> validate_compile_opt(Opt, Defs, Line, E) end, Opts).
+validate_compile_opts(Opts, Defs, Unreachable, Line, E) ->
+  lists:flatmap(fun (Opt) -> validate_compile_opt(Opt, Defs, Unreachable, Line, E) end, Opts).
 
 %% TODO: Make this an error on v2.0
-validate_compile_opt({parse_transform, Module} = Opt, _Defs, Line, E) ->
+validate_compile_opt({parse_transform, Module} = Opt, _Defs, _Unreachable, Line, E) ->
   elixir_errors:file_warn([{line, Line}], E, ?MODULE, {parse_transform, Module}),
   [Opt];
-validate_compile_opt({inline, Inlines} = Opt, Defs, Line, E) ->
-  [case lists:keyfind(Inline, 1, Defs) of
+validate_compile_opt({inline, Inlines}, Defs, Unreachable, Line, E) ->
+  case validate_inlines(Inlines, Defs, Unreachable, []) of
+    {ok, []} ->
+      [];
+    {ok, FilteredInlines} ->
+      [{inline, FilteredInlines}];
+    {error, Reason} ->
+      elixir_errors:module_error([{line, Line}], E, ?MODULE, Reason),
+      []
+  end;
+validate_compile_opt(Opt, Defs, Unreachable, Line, E) when is_list(Opt) ->
+  validate_compile_opts(Opt, Defs, Unreachable, Line, E);
+validate_compile_opt(Opt, _Defs, _Unreachable, _Line, _E) ->
+  [Opt].
+
+validate_inlines([Inline | Inlines], Defs, Unreachable, Acc) ->
+  case lists:keyfind(Inline, 1, Defs) of
     false ->
-      elixir_errors:module_error([{line, Line}], E, ?MODULE, {undefined_function, {compile, inline}, Inline});
+      {error, {undefined_function, {compile, inline}, Inline}};
     {_Def, Type, _Meta, _Clauses} when Type == defmacro; Type == defmacrop ->
-      elixir_errors:module_error([{line, Line}], E, ?MODULE, {bad_macro, {compile, inline}, Inline});
+      {error, {bad_macro, {compile, inline}, Inline}};
     _ ->
-      ok
-  end || Inline <- Inlines],
-  [Opt];
-validate_compile_opt(Opt, Defs, Line, E) when is_list(Opt) ->
-  validate_compile_opts(Opt, Defs, Line, E);
-validate_compile_opt(Opt, _Defs, _Line, _E) ->
-  [Opt].
+      case lists:member(Inline, Unreachable) of
+        true -> validate_inlines(Inlines, Defs, Unreachable, Acc);
+        false -> validate_inlines(Inlines, Defs, Unreachable, [Inline | Acc])
+      end
+  end;
+validate_inlines([], _Defs, _Unreachable, Acc) -> {ok, Acc}.
 
 validate_on_load_attribute({on_load, Def}, Defs, Private, Line, E) ->
   case lists:keyfind(Def, 1, Defs) of
@@ -534,23 +555,19 @@ beam_location(ModuleAsCharlist) ->
 
 checker_info() ->
   case get(elixir_checker_info) of
-    undefined -> nil;
+    undefined -> undefined;
     _ -> 'Elixir.Module.ParallelChecker':get()
   end.
 
-spawn_parallel_checker(DataBag, CheckerInfo, ModuleMap, Private, E) ->
+spawn_parallel_checker(undefined, _Module, _ModuleMap) ->
+  ok;
+spawn_parallel_checker(CheckerInfo, Module, ModuleMap) ->
   Log =
     case erlang:get(elixir_code_diagnostics) of
       {_, false} -> false;
       _ -> true
     end,
-
-  Used = bag_lookup_element(DataBag, macro_private_calls, 2),
-
-  case elixir_config:is_bootstrap() of
-    true -> ModuleMap;
-    false -> 'Elixir.Module.ParallelChecker':spawn(CheckerInfo, ModuleMap, Log, Private, Used, E)
-  end.
+  'Elixir.Module.ParallelChecker':spawn(CheckerInfo, Module, ModuleMap, Log).
 
 make_module_available(Module, Binary) ->
   case get(elixir_module_binaries) of

lib/elixir/test/elixir/kernel/errors_test.exs

@@ -739,8 +739,8 @@ defmodule Kernel.ErrorsTest do
     )
 
     assert_compile_error(
-      ["nofile:1: ", "undefined function foo/1 given to @compile :inline"],
-      ~c"defmodule Test do @compile {:inline, foo: 1}; defmacro foo(_) end"
+      ["nofile:1: ", "macro foo/1 given to @compile :inline"],
+      ~c"defmodule Test do @compile {:inline, foo: 1}; defmacro foo(_), do: :ok end"
     )
   end