More progress

Author: josevalim

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

@@ -188,7 +188,7 @@ defmodule Module.Types.Pattern do
       try do
         {types, of_pattern_var_deps(changed, vars_paths, vars_deps, tag, stack, context)}
       catch
-        {:error, context} -> {types, context}
+        {:error, context} -> {types, error_vars(pattern_info, context)}
       end
     catch
       {types, context} -> {types, error_vars(pattern_info, context)}
@@ -250,15 +250,16 @@ defmodule Module.Types.Pattern do
   end
 
   defp error_vars({args_paths, vars_paths, _vars_deps}, context) do
-    callback = fn {_, [%{var: var} | _paths]}, context ->
+    callback = fn [%{var: var} | _paths], context ->
       Of.error_var(var, context)
     end
 
-    context = Enum.reduce(args_paths, context, callback)
-    context = Enum.reduce(vars_paths, context, callback)
+    context = Enum.reduce(Map.values(args_paths), context, callback)
+    context = Enum.reduce(Map.values(vars_paths), context, callback)
     context
   end
 
+  # TODO: May pass the expression as well for more context
   defp refine_error({_, meta, _} = var, old_type, type, stack, context) do
     error(__MODULE__, {:badvar, old_type, type, var, context}, meta, stack, context)
   end
@@ -799,6 +800,7 @@ defmodule Module.Types.Pattern do
     {pattern_info, %{context | pattern_info: nil}}
   end
 
+  # TODO: Deal when new_type is none()
   def format_diagnostic({:badvar, old_type, new_type, var, context}) do
     traces = collect_traces(var, context)
 

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

@@ -54,21 +54,19 @@ defmodule Module.Types.PatternTest do
     test "errors on conflicting refinements" do
       assert typeerror!([a = b, a = :foo, b = :bar], {a, b}) ==
                ~l"""
-               the following pattern will never match:
+               incompatible types assigned to "a":
 
-                   a = b
+                   dynamic(:foo) !~ dynamic(:bar)
 
-               where "a" was given the type:
+               where "a" was given the types:
 
                    # type: dynamic(:foo)
-                   # from: types_test.ex:LINE-1
+                   # from: types_test.ex:55
                    a = :foo
 
-               where "b" was given the type:
-
                    # type: dynamic(:bar)
-                   # from: types_test.ex:LINE-1
-                   b = :bar
+                   # from: types_test.ex:55
+                   a = b
                """
     end
 
@@ -120,17 +118,31 @@ defmodule Module.Types.PatternTest do
       assert typeerror!([x = {:ok, _} = {:error, _, _}], x) == ~l"""
              the following pattern will never match:
 
-                 [_ | _] = x
+                 x = {:ok, _} = {:error, _, _}
+             """
 
-             because the right-hand side has type:
+      assert typeerror!([x = {:ok, y} = {:error, z, w}], {x, y, z, w}) == ~l"""
+             incompatible types assigned to "x":
 
-                 dynamic({:ok, term()})
+                 dynamic() !~ none()
 
              where "x" was given the type:
 
-                 # type: dynamic({:ok, term()})
-                 # from: types_test.ex:LINE
-                 x = {:ok, _}
+                 # type: none()
+                 # from: types_test.ex:124
+                 x = {:ok, y} = {:error, z, w}
+             """
+
+      assert typeerror!([{:ok, y} = {:error, z, w}], {y, z, w}) == ~l"""
+             incompatible types assigned to "match" (context Module.Types.Pattern):
+
+                 dynamic() !~ none()
+
+             where "match" (context Module.Types.Pattern) was given the type:
+
+                 # type: none()
+                 # from: types_test.ex:136
+                 {:ok, y} = {:error, z, w}
              """
 
       assert typeerror!([x = {:ok, _}], [_ | _] = x) == ~l"""