Check if the module is in the same context before checking if it is open

Author: José Valim

lib/elixir/include/elixir.hrl

@@ -22,7 +22,7 @@
   extra_guards=nil,        %% extra guards from args expansion
   counter=[],              %% a counter for the variables defined
   local=nil,               %% the scope to evaluate local functions against
-  scheduled=[],            %% scheduled modules to be loaded
+  context_modules=[],      %% modules defined in the current context
   macro_aliases=[],        %% keep aliases defined inside a macro
   aliases,                 %% an orddict with aliases by new -> old names
   file,                    %% the current scope filename

lib/elixir/lib/kernel.ex

@@ -3247,7 +3247,7 @@ defmodule Kernel do
       true ->
         fields =
           try do
-            case caller.module == atom or Module.open?(atom) do
+            case :lists.member(atom, caller.context_modules) and Module.open?(atom) do
               true  -> Module.get_attribute(atom, :record_fields)
               false -> atom.__record__(:fields)
             end
@@ -3258,7 +3258,7 @@ defmodule Kernel do
               # conflicts.
               case :code.ensure_loaded(atom) do
                 { :error, _ } ->
-                  raise "expected module #{inspect atom} to be loaded and defined"
+                  :elixir_aliases.ensure_loaded(caller.line, caller.file, atom, caller.context_modules)
                 _ ->
                   raise "cannot use module #{inspect atom} in access protocol because it does not export __record__/1"
               end

lib/elixir/lib/macro/env.ex

@@ -19,6 +19,7 @@ defmodule Macro.Env do
   * `requires` - the list of required modules
   * `functions` - a list of functions imported from each module
   * `macros` - a list of macros imported from each module
+  * `context_modules` - a list of modules defined in the current context
   """
 
   @type name_arity :: { atom, non_neg_integer }
@@ -29,13 +30,14 @@ defmodule Macro.Env do
   @type requires :: [module]
   @type functions :: [{ module, [name_arity] }]
   @type macros :: [{ module, [name_arity] }]
+  @type context_modules :: [module]
 
-  fields = [:module, :file, :line, :function,
-            :aliases, :context, :requires, :functions, :macros]
+  fields = [:module, :file, :line, :function, :aliases,
+            :context, :requires, :functions, :macros, :context_modules]
 
   types  = quote do: [module: module, file: file, line: line,
     function: name_arity, aliases: aliases, requires: requires,
-    functions: functions, macros: macros]
+    functions: functions, macros: macros, context_modules: context_modules]
 
   Record.deffunctions(fields, __MODULE__)
   Record.deftypes(fields, types, __MODULE__)

lib/elixir/src/elixir_aliases.erl

@@ -1,6 +1,6 @@
 -module(elixir_aliases).
 -export([nesting_alias/2, last/1, concat/1, safe_concat/1,
-  format_error/1, ensure_loaded/3, expand/3, store/4]).
+  format_error/1, ensure_loaded/3, ensure_loaded/4, expand/3, store/4]).
 -include("elixir.hrl").
 -compile({parse_transform, elixir_transform}).
 
@@ -65,19 +65,22 @@ expand_one(H, Aliases) ->
 
 %% Ensure a module is loaded before its usage.
 
-ensure_loaded(_Line, 'Elixir.Kernel', _S) ->
+ensure_loaded(Line, Ref, S) ->
+  ensure_loaded(Line, S#elixir_scope.file, Ref, S#elixir_scope.context_modules).
+
+ensure_loaded(_Line, _File, 'Elixir.Kernel', FileModules) ->
   ok;
 
-ensure_loaded(Line, Ref, S) ->
+ensure_loaded(Line, File, Ref, FileModules) ->
   try
     Ref:module_info(compile)
   catch
     error:undef ->
-      Kind = case lists:member(Ref, S#elixir_scope.scheduled) of
+      Kind = case lists:member(Ref, FileModules) of
         true  -> scheduled_module;
         false -> unloaded_module
       end,
-      elixir_errors:form_error(Line, S#elixir_scope.file, ?MODULE, { Kind, Ref })
+      elixir_errors:form_error(Line, File, ?MODULE, { Kind, Ref })
   end.
 
 %% Receives an atom and returns the last bit as an alias.

lib/elixir/src/elixir_macros.erl

@@ -205,7 +205,7 @@ translate({defmodule, Meta, [Ref, KV]}, S) ->
 
       {
         { atom, Meta, FullModule },
-        RS#elixir_scope{scheduled=[FullModule|S#elixir_scope.scheduled]}
+        RS#elixir_scope{context_modules=[FullModule|S#elixir_scope.context_modules]}
       };
     _ ->
       { TRef, S }

lib/elixir/src/elixir_module.erl

@@ -50,8 +50,13 @@ translate(Meta, Ref, Block, S) ->
 
 %% The compilation hook.
 
-compile(Line, Module, Block, Vars, #elixir_scope{} = S) when is_atom(Module) ->
+compile(Line, Module, Block, Vars, #elixir_scope{context_modules=FileModules} = RawS) when is_atom(Module) ->
   C = elixir_compiler:get_opts(),
+  S = case lists:member(Module, FileModules) of
+    true  -> RawS;
+    false -> RawS#elixir_scope{context_modules=[Module|FileModules]}
+  end,
+
   File = S#elixir_scope.file,
   FileList = binary_to_list(File),
 

lib/elixir/src/elixir_scope.erl

@@ -77,15 +77,18 @@ build_ex_var(Line, Key, Name, S) when is_integer(Line) ->
 
 % Handle Macro.Env conversion
 
-to_erl_env({ 'Elixir.Macro.Env', Module, File, _Line, Function, Aliases, Context, Requires, Functions, Macros }) ->
+to_erl_env({ 'Elixir.Macro.Env', Module, File, _Line, Function, Aliases, Context, Requires, Functions, Macros, FileModules }) ->
   #elixir_scope{module=Module,file=File,
     function=Function,aliases=Aliases,context=Context,
-    requires=Requires,macros=Macros,functions=Functions}.
+    requires=Requires,macros=Macros,functions=Functions,
+    context_modules=FileModules}.
 
 to_ex_env({ Line, #elixir_scope{module=Module,file=File,
     function=Function,aliases=Aliases,context=Context,
-    requires=Requires,macros=Macros,functions=Functions} }) when is_integer(Line) ->
-  { 'Elixir.Macro.Env', Module, File, Line, Function, Aliases, Context, Requires, Functions, Macros }.
+    requires=Requires,macros=Macros,functions=Functions,
+    context_modules=FileModules} }) when is_integer(Line) ->
+  { 'Elixir.Macro.Env', Module, File, Line, Function, Aliases,
+    Context, Requires, Functions, Macros, FileModules }.
 
 % Provides a tuple with only the scope information we want to serialize.
 
@@ -94,7 +97,7 @@ serialize(S) ->
     { S#elixir_scope.file, S#elixir_scope.functions,
       S#elixir_scope.requires, S#elixir_scope.macros, S#elixir_scope.aliases,
       S#elixir_scope.macro_functions, S#elixir_scope.macro_macros, S#elixir_scope.macro_aliases,
-      S#elixir_scope.scheduled }
+      S#elixir_scope.context_modules }
   ).
 
 serialize_with_vars(Line, S) when is_integer(Line) ->
@@ -113,7 +116,7 @@ serialize_with_vars(Line, S) when is_integer(Line) ->
 deserialize(Tuple) -> deserialize_with_vars(Tuple, []).
 
 deserialize_with_vars({ File, Functions, Requires, Macros,
-                        Aliases, MacroFunctions, MacroMacros, MacroAliases, Scheduled }, Vars) ->
+                        Aliases, MacroFunctions, MacroMacros, MacroAliases, FileModules }, Vars) ->
   #elixir_scope{
     file=File,
     functions=Functions,
@@ -123,7 +126,7 @@ deserialize_with_vars({ File, Functions, Requires, Macros,
     macro_functions=MacroFunctions,
     macro_macros=MacroMacros,
     macro_aliases=MacroAliases,
-    scheduled=Scheduled,
+    context_modules=FileModules,
     vars=orddict:from_list(Vars),
     counter=[{'',length(Vars)}]
   }.

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

@@ -205,7 +205,7 @@ defmodule Kernel.ErrorsTest do
   end
 
   test :invalid_access_protocol_not_available do
-    assert "expected module Unknown to be loaded and defined" ==
+    assert "nofile:2: module Unknown is not loaded and could not be found" ==
       format_rescue 'defmodule Foo do\ndef sample(Unknown[integer: 0]), do: true\nend'
   end