Do not add runtime deps for alias references in patterns and guards

Author: josevalim

lib/elixir/lib/code.ex

@@ -135,7 +135,7 @@ defmodule Code do
 
     * `{:require, meta, module, opts}` - traced whenever `module` is required.
       `meta` is the require AST metadata and `opts` are the require options.
-      If the `meta` option contains the `:from_macro`, then `require` was called
+      If the `meta` option contains the `:from_macro`, then module was called
       from within a macro and therefore must be treated as a compile-time dependency.
 
     * `{:struct_expansion, meta, module, keys}` - traced whenever `module`'s struct

lib/elixir/src/elixir_lexical.erl

@@ -56,7 +56,13 @@ trace({struct_expansion, _Meta, Module, _Keys}, #{lexical_tracker := Pid}) ->
   ?tracker:add_export(Pid, Module),
   ok;
 trace({alias_reference, _Meta, Module}, #{lexical_tracker := Pid} = E) ->
-  ?tracker:remote_dispatch(Pid, Module, mode(E)),
+  case E of
+    %% Alias references inside patterns and guards in functions are not
+    %% compile time dependencies.
+    #{function := nil} -> ?tracker:remote_dispatch(Pid, Module, compile);
+    #{context := nil} -> ?tracker:remote_dispatch(Pid, Module, runtime);
+    #{} -> ok
+  end,
   ok;
 trace({remote_function, _Meta, Module, _Function, _Arity}, #{lexical_tracker := Pid} = E) ->
   ?tracker:remote_dispatch(Pid, Module, mode(E)),

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

@@ -390,6 +390,44 @@ defmodule Kernel.LexicalTrackerTest do
       refute URI in runtime
     end
 
+    test "aliases in patterns and guards inside functions do not add runtime dependency" do
+      {{compile, exports, runtime, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.PatternGuardsRuntime do
+          def is_uri_atom(URI), do: true
+          def is_range_struct(range) when is_struct(range, Range), do: true
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      refute URI in compile
+      refute URI in exports
+      refute URI in runtime
+      refute Range in compile
+      refute Range in exports
+      refute Range in runtime
+    end
+
+    test "aliases in patterns and guards outside functions do add compile dependency" do
+      {{compile, exports, runtime, _}, _binding} =
+        Code.eval_string("""
+        defmodule Kernel.LexicalTrackerTest.PatternGuardsCompile do
+          %URI{} = URI.parse("/")
+          case 1..3 do
+            range when is_struct(range, Range) -> :ok
+          end
+          Kernel.LexicalTracker.references(__ENV__.lexical_tracker)
+        end |> elem(3)
+        """)
+
+      assert URI in compile
+      assert URI in exports
+      refute URI in runtime
+      assert Range in compile
+      refute Range in exports
+      refute Range in runtime
+    end
+
     test "compile_env! does not add a compile dependency" do
       {{compile, exports, runtime, _}, _binding} =
         Code.eval_string("""

lib/mix/lib/mix/tasks/xref.ex

@@ -517,15 +517,20 @@ defmodule Mix.Tasks.Xref do
   ## Trace
 
   @doc false
+  def trace({:alias_reference, meta, module}, env) when env.module != module do
+    case env do
+      %{function: nil} -> add_trace(:compile, :alias, module, module, meta, env)
+      %{context: nil} -> add_trace(:runtime, :alias, module, module, meta, env)
+      %{} -> :ok
+    end
+  end
+
   def trace({:require, meta, module, _opts}, env),
     do: add_trace(require_mode(meta), :require, module, module, meta, env)
 
   def trace({:struct_expansion, meta, module, _keys}, env),
     do: add_trace(:export, :struct, module, module, meta, env)
 
-  def trace({:alias_reference, meta, module}, env) when env.module != module,
-    do: add_trace(mode(env), :alias, module, module, meta, env)
-
   def trace({:remote_function, meta, module, function, arity}, env),
     do: add_trace(mode(env), :call, module, {module, function, arity}, meta, env)
 

lib/mix/test/mix/tasks/xref_test.exs

@@ -268,6 +268,29 @@ defmodule Mix.Tasks.XrefTest do
       assert_trace("lib/b.ex", files, output)
     end
 
+    test "ignores dependencies from patterns and guards" do
+      files = %{
+        "lib/a.ex" => ~S"""
+        defmodule A do
+          defstruct [:foo, :bar]
+        end
+        """,
+        "lib/b.ex" => ~S"""
+        defmodule B do
+          def pattern(A), do: true
+          def guard(a) when is_struct(a, A), do: true
+        end
+        """
+      }
+
+      output = """
+      Compiling 2 files (.ex)
+      Generated sample app
+      """
+
+      assert_trace("lib/b.ex", files, output)
+    end
+
     test "shows traces for module callbacks" do
       files = %{
         "lib/a.ex" => ~S"""