Refine hd/tl in guards, closes #15198

Author: josevalim

lib/elixir/lib/module/types/of.ex

@@ -48,7 +48,7 @@ defmodule Module.Types.Of do
   @doc """
   Declares a variable.
   """
-  def declare_var(var, context) do
+  def declare_var(var, type \\ term(), context) do
     {var_name, meta, var_context} = var
     version = Keyword.fetch!(meta, :version)
 
@@ -58,7 +58,7 @@ defmodule Module.Types.Of do
 
       vars ->
         data = %{
-          type: term(),
+          type: type,
           name: var_name,
           context: var_context,
           off_traces: [],

lib/elixir/lib/module/types/pattern.ex

@@ -408,6 +408,11 @@ defmodule Module.Types.Pattern do
     end)
   end
 
+  defp match_var do
+    version = make_ref()
+    {version, {:match, [version: version], __MODULE__}}
+  end
+
   defp match_error?({:match, _, __MODULE__}, _type), do: true
   defp match_error?(_var, type), do: empty?(type)
 
@@ -651,8 +656,8 @@ defmodule Module.Types.Pattern do
       |> Enum.split_while(&(not is_versioned_var(&1)))
       |> case do
         {matches, []} ->
-          version = make_ref()
-          {true, matches, version, {:match, [version: version], __MODULE__}}
+          {version, var} = match_var()
+          {true, matches, version, var}
 
         {pre, [{_, meta, _} = var | post]} ->
           version = Keyword.fetch!(meta, :version)
@@ -1018,7 +1023,8 @@ defmodule Module.Types.Pattern do
         guard_context: :andalso,
         parent_version: nil,
         vars: vars,
-        changed: %{}
+        changed: %{},
+        subpatterns: %{}
       })
 
     {precise?, context} = of_guards(guards, stack, context)
@@ -1064,7 +1070,7 @@ defmodule Module.Types.Pattern do
         {false, context}
 
       {true, maybe_or_always} ->
-        {maybe_or_always == :always, context}
+        {maybe_or_always == :always and context.pattern_info.subpatterns == %{}, context}
 
       _false_tuple_or_none ->
         error = {:badguard, type, guard, context}
@@ -1315,6 +1321,42 @@ defmodule Module.Types.Pattern do
     end
   end
 
+  # We cannot track precision for lists, so we assign match variables
+  # to hd/tl and refine them accordingly.
+  defp of_remote(
+         fun,
+         [arg],
+         call,
+         expected,
+         stack,
+         %{pattern_info: %{subpatterns: subpatterns}} = context
+       )
+       when fun in [:hd, :tl] do
+    arg_key =
+      Macro.prewalk(arg, fn
+        {left, meta, right} -> {left, Keyword.take(meta, [:version]), right}
+        node -> node
+      end)
+
+    subpattern_key = {fun, arg_key}
+
+    {var, context} =
+      case subpatterns do
+        %{^subpattern_key => var} ->
+          {var, context}
+
+        %{} ->
+          {type, context} =
+            Apply.remote(:erlang, fun, [arg], expected, call, stack, context, &of_guard/5)
+
+          {_, var} = match_var()
+          context = Of.declare_var(var, type, context)
+          {var, put_in(context.pattern_info.subpatterns[subpattern_key], var)}
+      end
+
+    of_guard(var, expected, call, stack, context)
+  end
+
   defp of_remote(fun, args, call, expected, stack, context) do
     Apply.remote(:erlang, fun, args, expected, call, stack, context, &of_guard/5)
   end

lib/elixir/test/elixir/module/types/pattern_test.exs

@@ -642,6 +642,31 @@ defmodule Module.Types.PatternTest do
              """
     end
 
+    test "hd/tl" do
+      assert typecheck!([x], is_list(x) and is_map(hd(x)) and is_map_key(hd(x), :tag), x) ==
+               dynamic(non_empty_list(term(), term()))
+
+      assert typeerror!([x], is_list(x) and is_map(hd(x)) and is_binary(hd(x)), x) =~ ~l"""
+             this guard will never succeed:
+
+                 is_list(x) and is_map(hd(x)) and is_binary(hd(x))
+
+             because it returns type:
+
+                 false
+
+             where "x" was given the types:
+
+                 # type: empty_list() or non_empty_list(term(), term())
+                 # from: types_test.ex:649
+                 is_list(x)
+
+                 # type: non_empty_list(term(), term())
+                 # from: types_test.ex:649
+                 hd(x)
+             """
+    end
+
     test "is_struct/1" do
       assert typecheck!([x], is_struct(x), x) == dynamic(open_map(__struct__: atom()))
       assert typecheck!([x], is_struct(x, URI), x) == dynamic(open_map(__struct__: atom([URI])))