Properly track types in lists in pattern matching, closes #15040

Author: josevalim

lib/elixir/lib/module/types.ex

@@ -446,6 +446,8 @@ defmodule Module.Types do
       warnings: [],
       # All vars and their types
       vars: %{},
+      # Stores special metadata need by heads in patterns
+      heads: %{},
       # Variables that are specific to the current environment/conditional
       conditional_vars: nil,
       # Track metadata specific to matches and guards

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

@@ -169,8 +169,8 @@ defmodule Module.Types.Of do
   Preserves `context` in first argument while
   resetting it to the vars in the second argument.
   """
-  def reset_vars(context, %{vars: vars, conditional_vars: conditional_vars}),
-    do: %{context | vars: vars, conditional_vars: conditional_vars}
+  def reset_vars(context, %{heads: heads, vars: vars, conditional_vars: conditional_vars}),
+    do: %{context | heads: heads, vars: vars, conditional_vars: conditional_vars}
 
   @doc """
   Executes the args with acc using conditional variables.

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

@@ -354,6 +354,17 @@ defmodule Module.Types.Pattern do
     end
   end
 
+  defp of_pattern_var([{:head, key} | rest], type, context) do
+    case list_hd(type) do
+      {:ok, head} ->
+        %{^key => tree} = context.heads
+        of_pattern_var(rest, intersection(head, of_pattern_tree(tree, context)), context)
+
+      _ ->
+        :error
+    end
+  end
+
   defp of_pattern_var([:tail | rest], type, context) do
     case list_tl(type) do
       {:ok, tail} -> of_pattern_var(rest, tail, context)
@@ -746,7 +757,18 @@ defmodule Module.Types.Pattern do
 
     result =
       Enum.reduce(prefix, {[], [], context}, fn arg, {static, dynamic, context} ->
-        {type, context} = of_pattern(arg, [:head | path], stack, context)
+        # These cases don't need to store head information because
+        # they have no intersection
+        {type, context} =
+          if is_number(arg) or is_binary(arg) or is_atom(arg) or arg == [] or is_var(arg) do
+            of_pattern(arg, [:head | path], stack, context)
+          else
+            %{heads: heads} = context
+            key = map_size(heads)
+            context = %{context | heads: Map.put(heads, key, nil)}
+            {type, context} = of_pattern(arg, [{:head, key} | path], stack, context)
+            {type, put_in(context.heads[key], type)}
+          end
 
         if is_descr(type) do
           {[type | static], dynamic, context}

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

@@ -344,6 +344,32 @@ defmodule Module.Types.PatternTest do
                )
              )
     end
+
+    test "regressions" do
+      # This is a regression that happens because stacktrace may be
+      # either three-element or four-element tuples, and it was failing
+      # when we tried to access the fourth element
+      assert typecheck!(
+               try do
+                 raise "oops"
+               rescue
+                 _ ->
+                   [{__MODULE__, fun, _args_or_arity, info} | _] = __STACKTRACE__
+                   {fun, length(info)}
+               end
+             ) == tuple([atom(), integer()])
+
+      assert typecheck!(
+               try do
+                 raise "oops"
+               rescue
+                 _ ->
+                   [tuple | _] = __STACKTRACE__
+                   {__MODULE__, fun, _args_or_arity, info} = tuple
+                   {fun, length(info)}
+               end
+             ) == tuple([atom(), integer()])
+    end
   end
 
   describe "bitstrings" do