Do not warn on conditional requires or requires from quote

Author: josevalim

lib/elixir/lib/code.ex

@@ -604,7 +604,7 @@ defmodule Code do
   all imports, requires and aliases defined in the current environment
   will be automatically carried over:
 
-      iex> require Integer
+      iex> require Integer, warn: false
       iex> {result, binding} = Code.eval_string("if Integer.is_odd(a), do: a + b", [a: 1, b: 2], __ENV__)
       iex> result
       3

lib/elixir/lib/kernel/lexical_tracker.ex

@@ -21,6 +21,15 @@ defmodule Kernel.LexicalTracker do
     :gen_server.call(pid, :references, @timeout)
   end
 
+  @doc """
+  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})
+    module
+  end
+
   @doc """
   Invoked during module expansion to annotate an alias
   must be warned if unused.
@@ -163,9 +172,7 @@ defmodule Kernel.LexicalTracker do
 
   def handle_call(:unused_requires, _from, state) do
     unused_requires =
-      for {module, meta} <- state.requires,
-          Map.get(state.references, module) != :compile,
-          Keyword.get(meta[:opts], :warn, true) != false do
+      for {module, meta} <- state.requires, Map.get(state.references, module) != :compile do
         {module, meta}
       end
 
@@ -267,7 +274,7 @@ defmodule Kernel.LexicalTracker do
     {:noreply, put_in(state.imports[module][@warn_key], true)}
   end
 
-  def handle_cast({:add_require, module, meta}, state) do
+  def handle_cast({:warn_require, module, meta}, state) do
     {:noreply, put_in(state.requires[module], meta)}
   end
 

lib/elixir/lib/macro/env.ex

@@ -300,7 +300,7 @@ defmodule Macro.Env do
 
       iex> Macro.Env.required?(__ENV__, Integer)
       false
-      iex> require Integer
+      iex> require Integer, warn: false
       iex> Macro.Env.required?(__ENV__, Integer)
       true
 

lib/elixir/lib/protocol.ex

@@ -1032,7 +1032,7 @@ defmodule Protocol do
     # expression (and therefore most likely a compile-time one).
     behaviour =
       if is_atom(protocol) do
-        quote(do: require(unquote(protocol), warn: false))
+        quote(do: require(unquote(protocol)))
       else
         quote(do: protocol)
       end

lib/elixir/src/elixir_expand.erl

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

lib/elixir/src/elixir_lexical.erl

@@ -34,12 +34,10 @@ run(#{tracers := Tracers} = E, ExecutionCallback, AfterExecutionCallback) ->
 trace({alias_expansion, _Meta, Lookup, _Result}, #{lexical_tracker := Pid}) ->
   ?tracker:alias_dispatch(Pid, Lookup),
   ok;
-trace({require, Meta, Module, Opts}, #{lexical_tracker := Pid, module := CurrentModule}) ->
+trace({require, Meta, Module, _Opts}, #{lexical_tracker := Pid}) ->
   case lists:keyfind(from_macro, 1, Meta) of
     {from_macro, true} -> ?tracker:remote_dispatch(Pid, Module, compile);
-    _ -> 
-      ?tracker:add_export(Pid, Module),
-      ?tracker:add_require(Pid, Module, [{module, CurrentModule}, {opts, Opts} | Meta])
+    _ -> ?tracker:add_export(Pid, Module)
   end,
   ok;
 trace({struct_expansion, _Meta, Module, _Keys}, #{lexical_tracker := Pid}) ->

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

@@ -91,56 +91,22 @@ defmodule Kernel.LexicalTrackerTest do
     assert D.collect_unused_imports(config[:pid]) == [{String, %{}}]
   end
 
-  test "unused requires", config do
-    D.add_require(config[:pid], String, module: TestModule, opts: [])
-    assert D.collect_unused_requires(config[:pid]) == [{String, [module: TestModule, opts: []]}]
-  end
-
-  test "used requires are not unused", config do
-    D.add_require(config[:pid], String, module: TestModule, opts: [])
-    D.remote_dispatch(config[:pid], String, :compile)
-    assert D.collect_unused_requires(config[:pid]) == []
-  end
-
-  test "requires with warn: false are not unused", config do
-    D.add_require(config[:pid], String, module: TestModule, opts: [warn: false])
-    assert D.collect_unused_requires(config[:pid]) == []
-  end
-
-  test "requires with warn: true are unused when not referenced", config do
-    D.add_require(config[:pid], String, module: TestModule, opts: [warn: true])
-
-    assert D.collect_unused_requires(config[:pid]) == [
-             {String, [module: TestModule, opts: [warn: true]]}
-           ]
-  end
-
-  test "multiple unused requires", config do
-    D.add_require(config[:pid], String, module: TestModule, opts: [])
-    D.add_require(config[:pid], List, module: TestModule, opts: [])
-
-    assert D.collect_unused_requires(config[:pid]) == [
-             {List, [module: TestModule, opts: []]},
-             {String, [module: TestModule, opts: []]}
-           ]
+  test "imports with no warn are not unused", config do
+    D.add_import(config[:pid], String, [], 1, false)
+    assert D.collect_unused_imports(config[:pid]) == []
   end
 
-  test "mixed used and unused requires", config do
-    D.add_require(config[:pid], String, module: TestModule, opts: [])
-    D.add_require(config[:pid], List, module: TestModule, opts: [])
+  test "unused requires", config do
+    D.warn_require(config[:pid], [], String)
+    D.warn_require(config[:pid], [], List)
     D.remote_dispatch(config[:pid], String, :compile)
-    assert D.collect_unused_requires(config[:pid]) == [{List, [module: TestModule, opts: []]}]
+    assert D.collect_unused_requires(config[:pid]) == [{List, []}]
   end
 
   test "function calls do not count as macro usage", config do
-    D.add_require(config[:pid], String, module: TestModule, opts: [])
+    D.warn_require(config[:pid], [], String)
     D.remote_dispatch(config[:pid], String, :runtime)
-    assert D.collect_unused_requires(config[:pid]) == [{String, [module: TestModule, opts: []]}]
-  end
-
-  test "imports with no warn are not unused", config do
-    D.add_import(config[:pid], String, [], 1, false)
-    assert D.collect_unused_imports(config[:pid]) == []
+    assert D.collect_unused_requires(config[:pid]) == [{String, []}]
   end
 
   test "unused aliases", config do

lib/elixir/test/elixir/kernel/macros_test.exs

@@ -10,13 +10,22 @@ defmodule Kernel.MacrosTest.Nested do
   defmacro do_identity!(do: x) do
     x
   end
+
+  defmacro unused_require do
+    quote do
+      require Integer
+    end
+  end
 end
 
 defmodule Kernel.MacrosTest do
   use ExUnit.Case, async: true
 
   Kernel.MacrosTest.Nested = require Kernel.MacrosTest.Nested, as: Nested
 
+  # Unused require from macro should not warn
+  Kernel.MacrosTest.Nested.unused_require()
+
   @spec my_macro :: Macro.t()
   defmacro my_macro do
     quote(do: 1 + 1)

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

@@ -2274,7 +2274,7 @@ defmodule Kernel.WarningTest do
       ["nofile:2:3", "unused require Application"],
       """
       defmodule Sample do
-        require Application 
+        require Application
         def a, do: nil
       end
       """
@@ -2283,13 +2283,26 @@ defmodule Kernel.WarningTest do
     assert_warn_compile(
       ["nofile:1:1", "unused require Logger"],
       """
-      require Logger 
+      require Logger
       """
     )
   after
     purge(Sample)
   end
 
+  test "conditional require" do
+    assert capture_err(fn ->
+             defmodule KernelTest.ConditionalRequire do
+               if false do
+                 require Integer
+                 def fun(x), do: Integer.is_odd(x)
+               end
+             end
+           end) == ""
+  after
+    purge(Sample)
+  end
+
   defp purge(module) when is_atom(module) do
     :code.purge(module)
     :code.delete(module)

lib/logger/lib/logger/app.ex

@@ -5,7 +5,6 @@
 defmodule Logger.App do
   @moduledoc false
 
-  require Logger
   use Application
 
   @doc false