Ensure all variables are propagated in a bad match, closes #13946

Author: josevalim

lib/elixir/lib/module/types/helpers.ex

@@ -86,7 +86,7 @@ defmodule Module.Types.Helpers do
           version = meta[:version]
 
           case vars do
-            %{^version => %{off_traces: [_ | _] = off_traces, name: name, context: context}} ->
+            %{^version => %{off_traces: off_traces, name: name, context: context}} ->
               {:ok,
                Map.put(versions, version, %{
                  type: :variable,

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

@@ -26,6 +26,23 @@ defmodule Module.Types.Of do
     type
   end
 
+  @doc """
+  Marks a variable with error.
+  """
+  def error_var(var, context) do
+    {var_name, meta, var_context} = var
+    version = Keyword.fetch!(meta, :version)
+
+    data = %{
+      type: error_type(),
+      name: var_name,
+      context: var_context,
+      off_traces: []
+    }
+
+    put_in(context.vars[version], data)
+  end
+
   @doc """
   Refines the type of a variable.
   """

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

@@ -123,15 +123,17 @@ defmodule Module.Types.Pattern do
     pattern_vars = Map.to_list(pattern_vars)
     changed = :lists.seq(0, length(types) - 1)
 
-    case callback.(types, changed, context) do
-      {:ok, types, context} ->
-        of_pattern_recur(types, pattern_vars, pattern_args, stack, context, callback)
+    try do
+      case callback.(types, changed, context) do
+        {:ok, types, context} ->
+          of_pattern_recur(types, pattern_vars, pattern_args, stack, context, callback)
 
-      {:error, context} ->
-        {types, context}
+        {:error, context} ->
+          {types, error_vars(pattern_vars, context)}
+      end
+    catch
+      {types, context} -> {types, error_vars(pattern_vars, context)}
     end
-  catch
-    {types, context} -> {types, context}
   end
 
   defp of_pattern_recur(types, vars, args, stack, context, callback) do
@@ -158,6 +160,7 @@ defmodule Module.Types.Pattern do
                   end
 
                 :error ->
+                  # TODO: This should be precised about the operation (case/=/try/etc)
                   context = Of.incompatible_error(expr, expected, actual, stack, context)
                   throw({types, context})
               end
@@ -193,11 +196,17 @@ defmodule Module.Types.Pattern do
           # A simple structural comparison for optimization
           {:ok, ^types, context} -> {types, context}
           {:ok, types, context} -> of_pattern_recur(types, vars, args, stack, context, callback)
-          {:error, context} -> {types, context}
+          {:error, context} -> {types, error_vars(vars, context)}
         end
     end
   end
 
+  defp error_vars(vars, context) do
+    Enum.reduce(vars, context, fn {_version, [[var | _path] | _paths]}, context ->
+      Of.error_var(var, context)
+    end)
+  end
+
   defp of_pattern_intersect(tree, expected, expr, stack, context) do
     actual = of_pattern_tree(tree, context)
     type = intersection(actual, expected)
@@ -212,6 +221,7 @@ defmodule Module.Types.Pattern do
         {:error, error(__MODULE__, {:invalid_pattern, expr, context}, meta, stack, context)}
 
       true ->
+        # TODO: This should be precised about the operation (case/=/try/etc)
         {:error, Of.incompatible_error(expr, expected, actual, stack, context)}
     end
   end

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

@@ -68,6 +68,16 @@ defmodule Module.Types.PatternTest do
                    b = :bar
                """
     end
+
+    test "can be access even if they don't match" do
+      assert typeerror!(
+               (
+                 # This will never match, info should not be "corrupted"
+                 [info | _] = __ENV__.function
+                 info
+               )
+             ) =~ "incompatible types in expression"
+    end
   end
 
   describe "structs" do