Track alias defined through require usage, closes #14789

Author: josevalim

lib/elixir/lib/kernel/lexical_tracker.ex

@@ -25,8 +25,8 @@ defmodule Kernel.LexicalTracker do
   Invoked during module expansion to annotate a require
   must be warned if unused.
   """
-  def warn_require(pid, meta, module) do
-    :gen_server.cast(pid, {:warn_require, module, meta})
+  def warn_require(pid, meta, module, alias) do
+    :gen_server.cast(pid, {:warn_require, module, meta, alias})
     module
   end
 
@@ -171,9 +171,12 @@ defmodule Kernel.LexicalTracker do
   end
 
   def handle_call(:unused_requires, _from, state) do
+    %{references: references, aliases: aliases} = state
+
     unused_requires =
-      for {module, meta} <- state.requires, Map.get(state.references, module) != :compile do
-        {module, meta}
+      for {module, {meta, alias}} <- state.requires,
+          Map.get(references, module) != :compile do
+        {module, meta, alias, Map.get(aliases, alias) == :used}
       end
 
     {:reply, Enum.sort(unused_requires), state}
@@ -274,8 +277,8 @@ defmodule Kernel.LexicalTracker do
     {:noreply, put_in(state.imports[module][@warn_key], true)}
   end
 
-  def handle_cast({:warn_require, module, meta}, state) do
-    {:noreply, put_in(state.requires[module], meta)}
+  def handle_cast({:warn_require, module, meta, alias}, state) do
+    {:noreply, put_in(state.requires[module], {meta, alias})}
   end
 
   @doc false

lib/elixir/src/elixir_expand.erl

@@ -121,18 +121,18 @@ expand({require, Meta, [Ref, Opts]}, S, E) ->
     false when is_atom(ERef) ->
       elixir_aliases:ensure_loaded(Meta, ERef, ET),
       RE = elixir_aliases:require(Meta, ERef, EOpts, ET, true),
-      {ok, _, EU} = alias(Meta, ERef, false, EOpts, RE),
+      {ok, Alias, EU} = alias(Meta, ERef, false, EOpts, RE),
 
       Quoted =
         case should_warn(Meta, EOpts, EU) of
           false ->
             ERef;
 
           Pid when ?key(EU, function) /= nil ->
-            ?tracker:warn_require(Pid, Meta, ERef);
+            ?tracker:warn_require(Pid, Meta, ERef, Alias);
 
           Pid ->
-            {{'.', Meta, [?tracker, warn_require]}, Meta, [Pid, Meta, ERef]}
+            {{'.', Meta, [?tracker, warn_require]}, Meta, [Pid, Meta, ERef, Alias]}
         end,
 
       {Quoted, ST, EU};

lib/elixir/src/elixir_lexical.erl

@@ -97,8 +97,8 @@ warn_unused_imports(Pid, E) ->
   ok.
 
 warn_unused_requires(Pid, E) ->
-  [elixir_errors:file_warn(Meta, ?key(E, file), ?MODULE, {unused_require, Module})
-   || {Module, Meta} <- ?tracker:collect_unused_requires(Pid)],
+  [elixir_errors:file_warn(Meta, ?key(E, file), ?MODULE, {unused_require, Module, Alias, AliasUsed})
+   || {Module, Meta, Alias, AliasUsed} <- ?tracker:collect_unused_requires(Pid)],
   ok.
 
 unused_imports_for_module(Module, Imports) ->
@@ -118,5 +118,10 @@ format_error({unused_import, {Module, Function, Arity}}) ->
   io_lib:format("unused import ~ts.~ts/~w", [elixir_aliases:inspect(Module), Function, Arity]);
 format_error({unused_import, Module}) ->
   io_lib:format("unused import ~ts", [elixir_aliases:inspect(Module)]);
-format_error({unused_require, Module}) ->
-  io_lib:format("unused require ~ts", [elixir_aliases:inspect(Module)]).
+format_error({unused_require, Module, Alias, AliasUsed}) ->
+  Message = if
+    Alias == false -> "unused require ~ts";
+    AliasUsed -> "unused require ~ts (convert it to an alias instead)";
+    true -> "unused require ~ts (the alias is also unused)"
+  end,
+  io_lib:format(Message, [elixir_aliases:inspect(Module)]).

lib/elixir/test/elixir/kernel/lexical_tracker_test.exs

@@ -97,16 +97,24 @@ defmodule Kernel.LexicalTrackerTest do
   end
 
   test "unused requires", config do
-    D.warn_require(config[:pid], [], String)
-    D.warn_require(config[:pid], [], List)
+    D.warn_require(config[:pid], [], String, false)
+    D.warn_require(config[:pid], [], List, false)
     D.remote_dispatch(config[:pid], String, :compile)
-    assert D.collect_unused_requires(config[:pid]) == [{List, []}]
+    assert D.collect_unused_requires(config[:pid]) == [{List, [], false, false}]
   end
 
   test "function calls do not count as macro usage", config do
-    D.warn_require(config[:pid], [], String)
+    D.warn_require(config[:pid], [], String, false)
     D.remote_dispatch(config[:pid], String, :runtime)
-    assert D.collect_unused_requires(config[:pid]) == [{String, []}]
+    assert D.collect_unused_requires(config[:pid]) == [{String, [], false, false}]
+  end
+
+  test "track alias usage through require", config do
+    D.warn_require(config[:pid], [], String, S)
+    D.remote_dispatch(config[:pid], String, :runtime)
+    assert D.collect_unused_requires(config[:pid]) == [{String, [], S, false}]
+    D.alias_dispatch(config[:pid], S)
+    assert D.collect_unused_requires(config[:pid]) == [{String, [], S, true}]
   end
 
   test "unused aliases", config do

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

@@ -2286,6 +2286,14 @@ defmodule Kernel.WarningTest do
   end
 
   test "unused require" do
+    assert_warn_compile(
+      ["nofile:1:1", "unused require Logger"],
+      """
+      require Logger
+      """
+    )
+
+    # Within a module
     assert_warn_compile(
       ["nofile:2:3", "unused require Application"],
       """
@@ -2296,10 +2304,25 @@ defmodule Kernel.WarningTest do
       """
     )
 
+    # Unused require and alias
     assert_warn_compile(
-      ["nofile:1:1", "unused require Logger"],
+      ["nofile:2:3", "unused require Application (the alias is also unused)"],
       """
-      require Logger
+      defmodule Sample do
+        require Application, as: A
+        def a, do: nil
+      end
+      """
+    )
+
+    # Unused require but used alias
+    assert_warn_compile(
+      ["nofile:2:3", "unused require Application (convert it to an alias instead)"],
+      """
+      defmodule Sample do
+        require Application, as: A
+        def a, do: A.started_applications()
+      end
       """
     )
   after