Fix bootstrap issues

Signed-off-by: José Valim <[email protected]>

Author: José Valim

lib/elixir/lib/macro.ex

@@ -833,7 +833,7 @@ defmodule Macro do
         :elixir_lexical.record_remote(receiver, env.lexical_tracker)
         {receiver, true}
       aliases ->
-        aliases = for alias <- aliases, do: elem(do_expand_once(alias, env), 0)
+        aliases = :lists.map(&elem(do_expand_once(&1, env), 0), aliases)
 
         case :lists.all(&is_atom/1, aliases) do
           true ->

lib/elixir/lib/module.ex

@@ -684,18 +684,18 @@ defmodule Module do
   def make_overridable(module, tuples) do
     assert_not_compiled!(:make_overridable, module)
 
-    for tuple <- tuples do
+    :lists.foreach(fn tuple ->
       case :elixir_def.lookup_definition(module, tuple) do
         false ->
           {name, arity} = tuple
           raise "Cannot make function #{name}/#{arity} overridable because it was not defined"
         clause ->
           :elixir_def.delete_definition(module, tuple)
 
-          neighbours = if loaded?(Module.LocalsTracker) do
-            Module.LocalsTracker.yank(module, tuple)
-          else
+          neighbours = if :elixir_compiler.get_opt(:internal) do
             []
+          else
+            Module.LocalsTracker.yank(module, tuple)
           end
 
           old    = :elixir_def_overridable.overridable(module)
@@ -704,7 +704,7 @@ defmodule Module do
           end, {1, clause, neighbours, false}, old)
           :elixir_def_overridable.overridable(module, merged)
       end
-    end
+    end, tuples)
   end
 
   @doc """
@@ -967,6 +967,4 @@ defmodule Module do
       raise ArgumentError,
         "could not call #{fun} on module #{inspect module} because it was already compiled"
   end
-
-  defp loaded?(module), do: is_tuple :code.is_loaded(module)
 end

lib/elixir/lib/protocol.ex

@@ -19,11 +19,12 @@ defmodule Protocol do
   defmacro def({name, _, args}) when is_atom(name) and is_list(args) do
     arity = length(args)
 
-    type_args = for _ <- :lists.seq(2, arity), do: quote(do: term)
+    type_args = :lists.map(fn _ -> quote(do: term) end,
+                           :lists.seq(2, arity))
     type_args = [quote(do: t) | type_args]
 
-    call_args = for i <- :lists.seq(2, arity),
-                  do: {String.to_atom(<<?x, i + 64>>), [], __MODULE__}
+    call_args = :lists.map(fn i -> {String.to_atom(<<?x, i + 64>>), [], __MODULE__} end,
+                           :lists.seq(2, arity))
     call_args = [quote(do: t) | call_args]
 
     quote do
@@ -440,7 +441,7 @@ defmodule Protocol do
       end
 
       # Define the implementation for builtins.
-      for {guard, mod} <- builtin do
+      :lists.foreach(fn {guard, mod} ->
         target = Module.concat(__MODULE__, mod)
 
         Kernel.def impl_for(data) when :erlang.unquote(guard)(data) do
@@ -449,7 +450,7 @@ defmodule Protocol do
             false -> any_impl_for
           end
         end
-      end
+      end, builtin)
 
       @spec impl_for!(term) :: atom() | no_return()
       Kernel.def impl_for!(data) do
@@ -609,16 +610,17 @@ defmodule Protocol do
   @doc false
   def __spec__?(module, name, arity) do
     signature = {name, arity}
-    specs     = Module.get_attribute(module, :spec)
 
+    specs = Module.get_attribute(module, :spec)
     found =
-      for {:spec, expr, caller} <- specs,
-        Kernel.Typespec.spec_to_signature(expr) == signature do
-        Kernel.Typespec.define_spec(:callback, expr, caller)
-        true
-      end
+      :lists.map(fn {:spec, expr, caller} ->
+        if Kernel.Typespec.spec_to_signature(expr) == signature do
+          Kernel.Typespec.define_spec(:callback, expr, caller)
+          true
+        end
+      end, specs)
 
-    found != []
+    :lists.any(& &1 == true, found)
   end
 
   ## Helpers

lib/elixir/src/elixir_bootstrap.erl

@@ -44,7 +44,7 @@ define({Line,E}, Kind, Call, Expr) ->
 unless_loaded(Fun, Args, Callback) ->
   case code:is_loaded(?kernel) of
     {_, _} -> apply(?kernel, Fun, Args);
-    false   -> Callback()
+    false  -> Callback()
   end.
 
 env() ->

lib/elixir/src/elixir_code_server.erl

@@ -30,12 +30,8 @@ start_link() ->
 
 init(ok) ->
   %% We attempt to load those modules here so throughout
-  %% the codebase we can use a code:is_loaded/1 check on
-  %% bootstrap instead of using the more expensive
-  %% code:ensure_loaded/1 multiple times.
+  %% the codebase we can avoid code:is_loaded/1 checks.
   _ = code:ensure_loaded('Elixir.Macro.Env'),
-  _ = code:ensure_loaded('Elixir.Module.LocalsTracker'),
-  _ = code:ensure_loaded('Elixir.Kernel.LexicalTracker'),
 
   %% The table where we store module definitions
   _ = ets:new(elixir_modules, [set, protected, named_table, {read_concurrency, true}]),

lib/elixir/src/elixir_def_overridable.erl

@@ -47,10 +47,10 @@ store(Module, Function, GenerateName) ->
         false -> {Kind, Name}
       end,
 
-      case code:is_loaded('Elixir.Module.LocalsTracker') of
-        {_, _} ->
+      case elixir_compiler:get_opt(internal) of
+        false ->
           'Elixir.Module.LocalsTracker':reattach(Module, Kind, {Name, Arity}, Neighbours);
-        _ ->
+        true ->
           ok
       end,
 

lib/elixir/src/elixir_lexical.erl

@@ -10,8 +10,8 @@
 -define(tracker, 'Elixir.Kernel.LexicalTracker').
 
 run(File, Dest, Callback) ->
-  case code:is_loaded(?tracker) of
-    {file, _} ->
+  case elixir_compiler:get_opt(internal) of
+    false ->
       {ok, Pid} = ?tracker:start_link(Dest),
       try
         Callback(Pid)
@@ -20,7 +20,7 @@ run(File, Dest, Callback) ->
         warn_unused_imports(File, Pid),
         unlink(Pid), ?tracker:stop(Pid)
       end;
-    false ->
+    true ->
       Callback(nil)
   end.
 

lib/elixir/src/elixir_locals.erl

@@ -72,12 +72,12 @@ rewrite_clause(Else, _) -> Else.
 %% TRACKING
 
 setup(Module) ->
-  case code:is_loaded(?tracker) of
-    {file, _} ->
+  case elixir_compiler:get_opt(internal) of
+    false ->
       {ok, Pid} = ?tracker:start_link(),
       ets:insert(elixir_module:data_table(Module), {?attr, Pid}),
       ok;
-    false ->
+    true ->
       ok
   end.
 

lib/elixir/src/elixir_module.erl

@@ -202,8 +202,8 @@ process_external_resource(Line, File, Value) ->
 %% Types
 
 types_form(Line, File, Data, Forms0) ->
-  case code:ensure_loaded('Elixir.Kernel.Typespec') of
-    {module, 'Elixir.Kernel.Typespec'} ->
+  case elixir_compiler:get_opt(internal) of
+    false ->
       Types0 = get_typespec(Data, type) ++ get_typespec(Data, typep)
                                         ++ get_typespec(Data, opaque),
 
@@ -215,7 +215,7 @@ types_form(Line, File, Data, Forms0) ->
       Forms2 = export_types_attributes(Types1, Forms1),
       typedocs_attributes(Types1, Forms2);
 
-    {error, _} ->
+    true ->
       Forms0
   end.
 
@@ -246,17 +246,16 @@ typedocs_attributes(Types, Forms) ->
 %% Specs
 
 specs_form(Data, Defmacro, Defmacrop, Forms) ->
-  case code:ensure_loaded('Elixir.Kernel.Typespec') of
-    {module, 'Elixir.Kernel.Typespec'} ->
+  case elixir_compiler:get_opt(internal) of
+    false ->
       Specs0 = get_typespec(Data, spec) ++ get_typespec(Data, callback),
       Specs1 = ['Elixir.Kernel.Typespec':translate_spec(Kind, Expr, Caller) ||
                 {Kind, Expr, Caller} <- Specs0],
       Specs2 = lists:flatmap(fun(Spec) ->
                                translate_macro_spec(Spec, Defmacro, Defmacrop)
                              end, Specs1),
       specs_attributes(Forms, Specs2);
-
-    {error, _} ->
+    true ->
       Forms
   end.