Clean up how we store recorded locals in the imports table

Author: José Valim

lib/elixir/src/elixir_def_local.erl

@@ -9,13 +9,12 @@
 -include("elixir.hrl").
 
 %% Used by elixir_dispatch, returns false if no macro is found
-macro_for(_Tuple, _All, nil) -> false;
+macro_for(_Tuple, _All, #elixir_scope{module=nil}) -> false;
 
-macro_for(Tuple, All, Module) ->
+macro_for(Tuple, All, #elixir_scope{module=Module} = S) ->
   try elixir_def:lookup_definition(Module, Tuple) of
     { { Tuple, Kind, Line, _, _, _, _ }, Clauses } when Kind == defmacro; All, Kind == defmacrop ->
-      %% This function is only called if S#elixir_scope.function /= Tuple
-      elixir_import:record(Tuple, Module, Module),
+      elixir_import:record_local(Tuple, S),
       get_function(Line, Module, Clauses);
     _ ->
       false

lib/elixir/src/elixir_dispatch.erl

@@ -41,11 +41,7 @@ import_function(Meta, Name, Arity, S) ->
     { import, Receiver } ->
       require_function(Meta, Receiver, Name, Arity, S);
     nomatch ->
-      Module = S#elixir_scope.module,
-      case S#elixir_scope.function of
-        Tuple -> ok;
-        _ -> elixir_import:record(Tuple, Module, Module)
-      end,
+      elixir_import:record_local(Tuple, S),
       { { 'fun', ?line(Meta), { function, Name, Arity } }, S }
   end.
 
@@ -128,7 +124,7 @@ do_expand_import(Meta, { Name, Arity } = Tuple, Args, Module, S, Result) ->
       expand_require(Meta, Receiver, Tuple, Args, Module, S);
     _ ->
       Fun = (S#elixir_scope.function /= Tuple) andalso
-        elixir_def_local:macro_for(Tuple, true, Module),
+        elixir_def_local:macro_for(Tuple, true, S),
       case Fun of
         false -> { error, noexpansion };
         _ ->
@@ -148,7 +144,7 @@ expand_require(Meta, ?BUILTIN, { Name, Arity } = Tuple, Args, Module, S) ->
 
 expand_require(Meta, Receiver, { Name, Arity } = Tuple, Args, Module, S) ->
   Fun = (Module == Receiver) andalso (S#elixir_scope.function /= Tuple) andalso
-    elixir_def_local:macro_for(Tuple, false, Module),
+    elixir_def_local:macro_for(Tuple, false, S),
 
   case Fun of
     false ->

lib/elixir/src/elixir_import.erl

@@ -2,12 +2,18 @@
 %% in between local functions and imports.
 %% For imports dispatch, please check elixir_dispatch.
 -module(elixir_import).
--export([import/5, recorded_locals/1, format_error/1,
+-export([import/5, record_local/2, recorded_locals/1, format_error/1,
   ensure_no_import_conflict/4, ensure_no_local_conflict/4,
   ensure_all_imports_used/3,
   build_table/1, delete_table/1, record/3]).
 -include("elixir.hrl").
 
+%% This table keeps:
+%%
+%% * Invoked imports and requires in the format { { Name, Arity }, Module }
+%% * The current warn status imports and requires in the format { Module, Line :: integer }
+%% * Invoked locals in the format { { Name, Arity }, Public :: boolean }
+%%
 table(Module) -> ?atom_concat([i, Module]).
 
 build_table(Module) ->
@@ -16,18 +22,20 @@ build_table(Module) ->
 delete_table(Module) ->
   ets:delete(table(Module)).
 
-record(_Tuple, _Receiver, nil) ->
-  false;
-
+record(_Tuple, _Receiver, nil) -> false;
 record(Tuple, Receiver, Module) ->
   try
     ets:insert(table(Module), { Tuple, Receiver })
   catch
     error:badarg -> false
   end.
 
-record_warn(_Meta, _Ref, _Opts, #elixir_scope{module=nil}) -> false;
+record_local(Tuple, #elixir_scope{function=Function})
+    when Function == nil; Function == Tuple -> false;
+record_local(Tuple, #elixir_scope{module=Module}) ->
+  record(Tuple, true, Module).
 
+record_warn(_Meta, _Ref, _Opts, #elixir_scope{module=nil}) -> false;
 record_warn(Meta, Ref, Opts, S) ->
   Table = table(S#elixir_scope.module),
   ets:delete(Table, Ref),
@@ -43,10 +51,15 @@ record_warn(Meta, Ref, Opts, S) ->
 
 recorded_locals(Module) ->
   Table  = table(Module),
-  Match  = { '$1', Module },
-  Result = ets:match(Table, Match),
-  ets:match_delete(Table, Match),
-  lists:append(Result).
+  Match  = module_local_spec(),
+  Result = ets:select(Table, Match),
+  ets:select_delete(Table, Match),
+  Result.
+
+module_local_spec() ->
+  [{ { '$1', '$2' }, [{ 'orelse', {'==','$2',true}, {'==','$2',false} }], ['$1'] }].
+
+%% IMPORT HELPERS
 
 %% Update the scope to consider the imports for aliases
 %% based on the given options and selector.
@@ -80,16 +93,13 @@ import(Meta, Ref, Opts, Selector, S) ->
   record_warn(Meta, Ref, Opts, S),
   SM.
 
-%% IMPORT FUNCTION RELATED HELPERS
-
 %% Calculates the imports based on only and except
 
 calculate(Meta, Key, Opts, Old, Temp, AvailableFun, S) ->
   File = S#elixir_scope.file,
 
   New = case keyfind(only, Opts) of
-    { only, RawOnly } ->
-      Only = expand_fun_arity(Meta, only, RawOnly, S),
+    { only, Only } ->
       case Only -- get_exports(Key) of
         [{Name,Arity}|_] ->
           Tuple = { invalid_import, { Key, Name, Arity } },
@@ -101,8 +111,7 @@ calculate(Meta, Key, Opts, Old, Temp, AvailableFun, S) ->
       case keyfind(except, Opts) of
         false -> AvailableFun(true);
         { except, [] } -> AvailableFun(true);
-        { except, RawExcept } ->
-          Except = expand_fun_arity(Meta, except, RawExcept, S),
+        { except, Except } ->
           case keyfind(Key, Old) of
             false -> AvailableFun(true) -- Except;
             {Key,OldImports} -> OldImports -- Except
@@ -134,29 +143,6 @@ if_quoted(Meta, Temp, Callback) ->
       Temp
   end.
 
-%% Ensure we are expanding macros and stuff
-
-expand_fun_arity(Meta, Kind, Value, S) ->
-  { TValue, _S } = elixir_translator:translate_each(Value, S),
-  cons_to_keywords(Meta, Kind, TValue, S).
-
-cons_to_keywords(Meta, Kind, { cons, _, Left, { nil, _ } }, S) ->
-  [tuple_to_fun_arity(Meta, Kind, Left, S)];
-
-cons_to_keywords(Meta, Kind, { cons, _, Left, Right }, S) ->
-  [tuple_to_fun_arity(Meta, Kind, Left, S)|cons_to_keywords(Meta, Kind, Right, S)];
-
-cons_to_keywords(Meta, Kind, _, S) ->
-  elixir_errors:syntax_error(Meta, S#elixir_scope.file,
-    "invalid value for :~ts, expected a list with functions and arities", [Kind]).
-
-tuple_to_fun_arity(_Meta, _Kind, { tuple, _, [{ atom, _, Atom }, { integer, _, Integer }] }, _S) ->
-  { Atom, Integer };
-
-tuple_to_fun_arity(Meta, Kind, _, S) ->
-  elixir_errors:syntax_error(Meta, S#elixir_scope.file,
-    "invalid value for :~ts, expected a list with functions and arities", [Kind]).
-
 %% Retrieve functions and macros from modules
 
 get_exports(Module) ->
@@ -207,26 +193,33 @@ ensure_no_local_conflict(Meta, File, Module, AllDefined) ->
 
 ensure_no_import_conflict(Meta, File, Module, AllDefined) ->
   Table = table(Module),
-  Matches = [X || X <- AllDefined, ets:member(Table, X)],
+  [ensure_no_import_conflict(Meta, File, Module, Table, X) || X  <- AllDefined],
+  ok.
+
+ensure_no_import_conflict(Meta, File, Module, Table, { Name, Arity } = Tuple) ->
+  RawMatches = ets:match(Table, { Tuple, '$1' }),
+  Matches = [X || X <- lists:append(RawMatches), not is_boolean(X), X /= Module],
 
   case Matches of
-    [{Name,Arity}|_] ->
-      Key = ets:lookup_element(Table, { Name, Arity }, 2),
-      Tuple = { import_conflict, { hd(Key), Name, Arity } },
-      elixir_errors:form_error(Meta, File, ?MODULE, Tuple);
-    [] ->
-      ok
+    []  -> ok;
+    Key ->
+      Error = { import_conflict, { hd(Key), Name, Arity } },
+      elixir_errors:form_error(Meta, File, ?MODULE, Error)
   end.
 
+%% Ensure all imports are used by checking all
+%% enabled warnings in the table with the imported
+%% function calls.
+
 ensure_all_imports_used(_Line, File, Module) ->
   Table = table(Module),
-  [begin
-    elixir_errors:handle_file_warning(File, { L, ?MODULE, { unused_import, M } })
-   end || [M, L] <- ets:select(Table, module_line_spec()),
-          ets:match(Table, { '$1', M }) == []].
+  [ begin
+      elixir_errors:handle_file_warning(File, { L, ?MODULE, { unused_import, M } })
+    end || { M, L } <- ets:select(Table, module_line_spec()),
+           ets:match(Table, { '$1', M }) == []].
 
 module_line_spec() ->
-  [{ { '$1', '$2' }, [{ is_integer, '$2' }], ['$$'] }].
+  [{ { '$1', '$2' }, [{ is_integer, '$2' }], ['$_'] }].
 
 %% Ensure the given functions don't clash with any
 %% of Elixir non overridable macros.
@@ -287,8 +280,6 @@ intersection([H|T], All) ->
 
 intersection([], _All) -> [].
 
-%% INTROSPECTION
-
 %% Internal funs that are never imported etc.
 
 remove_underscored(default, List) -> remove_underscored(List);
@@ -308,7 +299,7 @@ remove_internals(Set) ->
   ordsets:del_element({ module_info, 1 },
     ordsets:del_element({ module_info, 0 }, Set)).
 
-%% Macros implemented in Erlang that are not overridable.
+%% Macros implemented in Erlang that are not importable.
 
 special_form() ->
   [

lib/elixir/src/elixir_translator.erl

@@ -577,11 +577,8 @@ translate_fn(Meta, Clauses, S) ->
 
 %% Locals
 
-translate_local(Meta, Name, Args, #elixir_scope{local=nil,module=Module,function=Function} = S) ->
-  case { Name, length(Args) } of
-    Function -> ok;
-    Tuple    -> elixir_import:record(Tuple, Module, Module)
-  end,
+translate_local(Meta, Name, Args, #elixir_scope{local=nil} = S) ->
+  elixir_import:record_local({ Name, length(Args) }, S),
   Line = ?line(Meta),
   { TArgs, NS } = translate_args(Args, S),
   { { call, Line, { atom, Line, Name }, TArgs }, NS };