Add warnings for unused aliases

Author: José Valim

lib/elixir/lib/kernel/special_forms.ex

@@ -321,6 +321,18 @@ defmodule Kernel.SpecialForms do
   `import`, `require` and `alias` are called directives and all
   have lexical scope. This means you can set up aliases inside
   specific functions and it won't affect the overall scope.
+
+  ## Warnings
+
+  If you alias a module and you don't use the alias, Elixir is
+  going to issue a warning implying the alias is not being used.
+
+  In case the alias is generated automatically by a macro,
+  Elixir won't emit any warnings though, since the alias
+  was not explicitly defined.
+
+  Both warning behaviors could be changed by explicitily
+  setting the `:warn` option to true or false.
   """
   defmacro alias(module, opts)
 

lib/elixir/lib/macro.ex

@@ -534,17 +534,17 @@ defmodule Macro do
   end
 
   defp expand_once({ :__aliases__, _, _ } = original, env, cache) do
-    case :elixir_aliases.expand(original, env.aliases, env.macro_aliases) do
+    case :elixir_aliases.expand(original, env.aliases, env.macro_aliases, env.lexical_tracker) do
       receiver when is_atom(receiver) ->
-        :elixir_lexical.record_alias(receiver, env.lexical_tracker)
+        :elixir_lexical.record_remote(receiver, env.lexical_tracker)
         { receiver, true, cache }
       aliases ->
         aliases = lc alias inlist aliases, do: elem(expand_once(alias, env, cache), 0)
 
         case :lists.all(&is_atom/1, aliases) do
           true ->
             receiver = :elixir_aliases.concat(aliases)
-            :elixir_lexical.record_alias(receiver, env.lexical_tracker)
+            :elixir_lexical.record_remote(receiver, env.lexical_tracker)
             { receiver, true, cache }
           false -> { original, false, cache }
         end

lib/elixir/src/elixir_aliases.erl

@@ -1,11 +1,13 @@
 -module(elixir_aliases).
 -export([nesting_alias/2, last/1, concat/1, safe_concat/1,
-  format_error/1, ensure_loaded/3, ensure_loaded/4, expand/3, store/4]).
+  format_error/1, ensure_loaded/3, ensure_loaded/4, expand/4, store/5]).
 -include("elixir.hrl").
 
 %% Store an alias in the given scope
-store(_Meta, New, New, S) -> S;
-store(Meta, New, Old, S) ->
+store(_Meta, New, New, _TKV, S) -> S;
+store(Meta, New, Old, TKV, S) ->
+  record_warn(Meta, New, TKV, S),
+
   SA = S#elixir_scope{
     aliases=orddict:store(New, Old, S#elixir_scope.aliases)
   },
@@ -19,47 +21,58 @@ store(Meta, New, Old, S) ->
       SA
   end.
 
+record_warn(Meta, Ref, Opts, S) ->
+  Warn =
+    case lists:keyfind(warn, 1, Opts) of
+      { warn, false } -> false;
+      { warn, true } -> true;
+      false -> not lists:keymember(context, 1, Meta)
+    end,
+  elixir_lexical:record_alias(Ref, ?line(Meta), Warn, S#elixir_scope.lexical_tracker).
+
 %% Expand an alias. It returns an atom (meaning that there
 %% was an expansion) or a list of atoms.
 
-expand({ '__aliases__', Meta, _ } = Alias, Aliases, MacroAliases) ->
+expand({ '__aliases__', Meta, _ } = Alias, Aliases, MacroAliases, LexicalTracker) ->
   case lists:keyfind(alias, 1, Meta) of
     { alias, false } ->
-      expand(Alias, MacroAliases);
+      expand(Alias, MacroAliases, LexicalTracker);
     { alias, Atom } when is_atom(Atom) ->
-      case expand(Alias, MacroAliases) of
+      case expand(Alias, MacroAliases, LexicalTracker) of
         OtherAtom when is_atom(OtherAtom) -> OtherAtom;
         OtherAliases when is_list(OtherAliases) -> Atom
       end;
     false ->
-      expand(Alias, Aliases)
+      expand(Alias, Aliases, LexicalTracker)
   end.
 
-expand({ '__aliases__', _Meta, [H] }, Aliases) when H /= 'Elixir' ->
-  case expand_one(H, Aliases) of
+expand({ '__aliases__', _Meta, [H] }, Aliases, LexicalTracker) when H /= 'Elixir' ->
+  case expand_one(H, Aliases, LexicalTracker) of
     false -> [H];
     Atom  -> Atom
   end;
 
-expand({ '__aliases__', _Meta, [H|T] }, Aliases) when is_atom(H) ->
+expand({ '__aliases__', _Meta, [H|T] }, Aliases, LexicalTracker) when is_atom(H) ->
   case H of
     'Elixir' ->
       concat(T);
     _ ->
-      case expand_one(H, Aliases) of
+      case expand_one(H, Aliases, LexicalTracker) of
         false -> [H|T];
         Atom  -> concat([Atom|T])
       end
   end;
 
-expand({ '__aliases__', _Meta, List }, _Aliases) ->
+expand({ '__aliases__', _Meta, List }, _Aliases, _LexicalTracker) ->
   List.
 
-expand_one(H, Aliases) ->
+expand_one(H, Aliases, LexicalTracker) ->
   Lookup = list_to_atom("Elixir." ++ atom_to_list(H)),
   case lookup(Lookup, Aliases) of
     Lookup -> false;
-    Else   -> Else
+    Else ->
+      elixir_lexical:record_alias(Lookup, LexicalTracker),
+      Else
   end.
 
 %% Ensure a module is loaded before its usage.

lib/elixir/src/elixir_lexical.erl

@@ -17,6 +17,7 @@ run(File, Callback) ->
       try
         Callback(Pid)
       after
+        warn_unused_aliases(File, Pid),
         warn_unused_imports(File, Pid),
         unlink(Pid), ?tracker:stop(Pid)
       end;
@@ -68,5 +69,12 @@ warn_unused_imports(File, Pid) ->
       elixir_errors:handle_file_warning(File, { L, ?MODULE, { unused_import, M } })
     end || { M, L } <- ?tracker:collect_unused_imports(Pid)].
 
+warn_unused_aliases(File, Pid) ->
+  [ begin
+      elixir_errors:handle_file_warning(File, { L, ?MODULE, { unused_alias, M } })
+    end || { M, L } <- ?tracker:collect_unused_aliases(Pid)].
+
+format_error({unused_alias, Module}) ->
+  io_lib:format("unused alias ~ts", [elixir_errors:inspect(Module)]);
 format_error({unused_import, Module}) ->
   io_lib:format("unused import ~ts", [elixir_errors:inspect(Module)]).

lib/elixir/src/elixir_macros.erl

@@ -163,7 +163,7 @@ translate({defmodule, Meta, [Ref, KV]}, S) when is_list(KV) ->
       FullModule = expand_module(Ref, Module, S),
 
       RS = case elixir_aliases:nesting_alias(S#elixir_scope.module, FullModule) of
-        { New, Old } -> elixir_aliases:store(Meta, New, Old, S);
+        { New, Old } -> elixir_aliases:store(Meta, New, Old, [{warn,false}], S);
         false -> S
       end,
 
@@ -308,7 +308,8 @@ expand_module({ '__aliases__', _, [H] }, _Module, S) ->
 
 %% defmodule Hello.World
 expand_module({ '__aliases__', _, _ } = Alias, Module, S) ->
-  case elixir_aliases:expand(Alias, S#elixir_scope.aliases, S#elixir_scope.macro_aliases) of
+  case elixir_aliases:expand(Alias, S#elixir_scope.aliases, S#elixir_scope.macro_aliases,
+                             S#elixir_scope.lexical_tracker) of
     Atom when is_atom(Atom) ->
       Module;
     Aliases when is_list(Aliases) ->

lib/elixir/src/elixir_quote.erl

@@ -174,7 +174,7 @@ do_quote({ 'alias!', _Meta, [Expr] }, #elixir_quote{aliases_hygiene=true} = Q, S
   { TExpr, TQ#elixir_quote{aliases_hygiene=true} };
 
 do_quote({ '__aliases__', Meta, [H|T] } = Alias, #elixir_quote{aliases_hygiene=true} = Q, S) when is_atom(H) and (H /= 'Elixir') ->
-  Annotation = case elixir_aliases:expand(Alias, S#elixir_scope.aliases, S#elixir_scope.macro_aliases) of
+  Annotation = case elixir_aliases:expand(Alias, S#elixir_scope.aliases, S#elixir_scope.macro_aliases, S#elixir_scope.lexical_tracker) of
     Atom when is_atom(Atom) -> Atom;
     Aliases when is_list(Aliases) -> false
   end,

lib/elixir/src/elixir_translator.erl

@@ -87,7 +87,7 @@ translate_each({ alias, Meta, [Ref] }, S) ->
 translate_each({ alias, Meta, [Ref, KV] }, S) ->
   assert_no_match_or_guard_scope(Meta, alias, S),
   { TRef, SR } = translate_each(Ref, S),
-  { TKV, ST }  = translate_opts(Meta, alias, [as], no_alias_opts(KV), SR),
+  { TKV, ST }  = translate_opts(Meta, alias, [as, warn], no_alias_opts(KV), SR),
 
   case TRef of
     { atom, _, Old } ->
@@ -103,7 +103,7 @@ translate_each({ require, Meta, [Ref, KV] }, S) ->
   assert_no_match_or_guard_scope(Meta, require, S),
 
   { TRef, SR } = translate_each(Ref, S),
-  { TKV, ST }  = translate_opts(Meta, require, [as], no_alias_opts(KV), SR),
+  { TKV, ST }  = translate_opts(Meta, require, [as, warn], no_alias_opts(KV), SR),
 
   case TRef of
     { atom, _, Old } ->
@@ -151,9 +151,9 @@ translate_each({ '__CALLER__', Meta, Atom }, S) when is_atom(Atom) ->
 %% Aliases
 
 translate_each({ '__aliases__', Meta, _ } = Alias, S) ->
-  case elixir_aliases:expand(Alias, S#elixir_scope.aliases, S#elixir_scope.macro_aliases) of
+  case elixir_aliases:expand(Alias, S#elixir_scope.aliases, S#elixir_scope.macro_aliases, S#elixir_scope.lexical_tracker) of
     Receiver when is_atom(Receiver) ->
-      elixir_lexical:record_alias(Receiver, S#elixir_scope.lexical_tracker),
+      elixir_lexical:record_remote(Receiver, S#elixir_scope.lexical_tracker),
       { { atom, ?line(Meta), Receiver }, S };
     Aliases ->
       { TAliases, SA } = translate_args(Aliases, S),
@@ -162,7 +162,7 @@ translate_each({ '__aliases__', Meta, _ } = Alias, S) ->
         true ->
           Atoms = [Atom || { atom, _, Atom } <- TAliases],
           Receiver = elixir_aliases:concat(Atoms),
-          elixir_lexical:record_alias(Receiver, S#elixir_scope.lexical_tracker),
+          elixir_lexical:record_remote(Receiver, S#elixir_scope.lexical_tracker),
           { { atom, ?line(Meta), Receiver }, SA };
         false ->
           Args = [elixir_utils:list_to_cons(?line(Meta), TAliases)],
@@ -523,7 +523,7 @@ translate_alias(Meta, IncludeByDefault, Old, TKV, S) ->
                "invalid :as for alias, nested alias ~s not allowed", [elixir_errors:inspect(New)])
   end,
 
-  { { atom, ?line(Meta), nil }, elixir_aliases:store(Meta, New, Old, S) }.
+  { { atom, ?line(Meta), nil }, elixir_aliases:store(Meta, New, Old, TKV, S) }.
 
 no_alias_opts(KV) when is_list(KV) ->
   case lists:keyfind(as, 1, KV) of

lib/elixir/test/elixir/kernel/alias_test.exs

@@ -29,9 +29,9 @@ defmodule Kernel.AliasTest do
 
   test :lexical do
     if true do
-      alias OMG, as: List
+      alias OMG, as: List, warn: false
     else
-      alias ABC, as: List
+      alias ABC, as: List, warn: false
     end
 
     assert List.flatten([1, [2], 3]) == [1, 2, 3]

lib/elixir/test/elixir/kernel/quote_test.exs

@@ -327,13 +327,13 @@ defmodule Kernel.QuoteTest.AliasHygieneTest do
   end
 
   test :expand_aliases_with_macro_does_not_expand_source_alias do
-    alias HashDict, as: Dict
+    alias HashDict, as: Dict, warn: false
     require Kernel.QuoteTest.AliasHygiene
     assert Kernel.QuoteTest.AliasHygiene.dict == Elixir.Dict.Bar
   end
 
   test :expand_aliases_with_macro_has_higher_preference do
-    alias HashDict, as: SuperDict
+    alias HashDict, as: SuperDict, warn: false
     require Kernel.QuoteTest.AliasHygiene
     assert Kernel.QuoteTest.AliasHygiene.super_dict == Elixir.Dict.Bar
   end

lib/elixir/test/elixir/kernel/warning_test.exs

@@ -138,18 +138,27 @@ defmodule Kernel.WarningTest do
   test :unused_import do
     assert capture_err(fn ->
       Code.compile_string """
-      defmodule Sample1 do
-        def hello, do: nil
+      defmodule Sample do
+        import :lists, only: [flatten: 1]
+        def a, do: nil
       end
+      """
+    end) =~ "unused import :lists"
+  after
+    purge [Sample]
+  end
 
-      defmodule Sample2 do
-        import Sample1
+  test :unused_alias do
+    assert capture_err(fn ->
+      Code.compile_string """
+      defmodule Sample do
+        alias :lists, as: List
         def a, do: nil
       end
       """
-    end) =~ "unused import Sample1"
+    end) =~ "unused alias List"
   after
-    purge [Sample1, Sample2]
+    purge [Sample]
   end
 
   test :unused_guard do