Surface errors earlier whenever possible

Author: josevalim

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

@@ -458,26 +458,26 @@ defmodule Module.Types.Pattern do
 
   # left = right
   defp of_pattern({:=, _meta, [_, _]} = match, path, stack, context) do
-    {match, version, var} =
+    {matches, version, var} =
       match
       |> unpack_match([])
       |> Enum.split_while(&(not is_versioned_var(&1)))
       |> case do
-        {match, []} ->
+        {matches, []} ->
           version = make_ref()
-          {match, version, {:match, [version: version], __MODULE__}}
+          {matches, version, {:match, [version: version], __MODULE__}}
 
         {pre, [{_, meta, _} = var | post]} ->
           version = Keyword.fetch!(meta, :version)
           {pre ++ post, version, var}
       end
 
     # Pass the current path to build the current var
-    {expr, context} = of_var(var, version, path, context)
-    root = %{root: {:var, version}, expr: expr}
+    context = of_var(var, version, path, context)
+    root = %{root: {:var, version}, expr: match}
 
     {static, dynamic, context} =
-      Enum.reduce(match, {[], [], context}, fn pattern, {static, dynamic, context} ->
+      Enum.reduce(matches, {[], [], context}, fn pattern, {static, dynamic, context} ->
         {type, context} = of_pattern(pattern, [root], stack, context)
 
         if is_descr(type) do
@@ -491,14 +491,13 @@ defmodule Module.Types.Pattern do
       {Enum.reduce(static, &intersection/2), context}
     else
       # The dynamic parts have to be recomputed whenever they change
-      {var, context} =
-        of_pattern(var, [%{root: {:intersection, dynamic}, expr: expr}], stack, context)
+      context = of_var(var, version, [%{root: {:intersection, dynamic}, expr: match}], context)
 
-      # But the static parts we push down as part of the argument intersection
+      # And everything else is also pushed as part of the argument intersection
       if static == [] do
-        {var, context}
+        {{:intersection, dynamic}, context}
       else
-        {{:intersection, [var, Enum.reduce(static, &intersection/2)]}, context}
+        {{:intersection, [Enum.reduce(static, &intersection/2) | dynamic]}, context}
       end
     end
   end
@@ -601,8 +600,7 @@ defmodule Module.Types.Pattern do
   defp of_pattern({name, meta, ctx} = var, path, _stack, context)
        when is_atom(name) and is_atom(ctx) do
     version = Keyword.fetch!(meta, :version)
-    {_, context} = of_var(var, version, path, context)
-    {{:var, version}, context}
+    {{:var, version}, of_var(var, version, path, context)}
   end
 
   defp is_versioned_var({name, _meta, ctx}) when is_atom(name) and is_atom(ctx) and name != :_,
@@ -636,7 +634,7 @@ defmodule Module.Types.Pattern do
           {args_paths, vars_paths, vars_deps}
       end
 
-    {expr, %{context | pattern_info: pattern_info}}
+    %{context | pattern_info: pattern_info}
   end
 
   # TODO: Properly traverse domain keys

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

@@ -51,24 +51,6 @@ defmodule Module.Types.PatternTest do
                """
     end
 
-    test "errors on conflicting refinements" do
-      assert typeerror!([a = b, a = :foo, b = :bar], {a, b}) == ~l"""
-             incompatible types assigned to "a":
-
-                 dynamic(:foo) !~ dynamic(:bar)
-
-             where "a" was given the types:
-
-                 # type: dynamic(:foo)
-                 # from: types_test.ex:LINE
-                 a = :foo
-
-                 # type: dynamic(:bar)
-                 # from: types_test.ex:LINE
-                 a = b
-             """
-    end
-
     test "can be accessed even if they don't match" do
       assert typeerror!(
                (
@@ -126,32 +108,44 @@ defmodule Module.Types.PatternTest do
                  x = {:ok, _} = {:error, _, _}
              """
 
-      assert typeerror!([x = {:ok, y} = {:error, z, w}], {x, y, z, w}) == ~l"""
-             this match will never succeed due to incompatible types:
+      assert typeerror!([{x = {:ok, y} = {:error, z, w}}], {x, y, z, w}) == ~l"""
+             the following pattern will never match:
 
-                 x = {:ok, y} = {:error, z, w}
+                 {x = {:ok, y} = {:error, z, w}}
              """
 
-      assert typeerror!([{:ok, y} = {:error, z, w}], {y, z, w}) == ~l"""
-             this match will never succeed due to incompatible types:
+      assert typeerror!([a = b, a = :foo, b = :bar], {a, b}) == ~l"""
+             incompatible types assigned to "a":
 
-                 {:ok, y} = {:error, z, w}
-             """
+                 dynamic(:foo) !~ dynamic(:bar)
 
-      assert typeerror!([x = {:ok, _}], [_ | _] = x) == ~l"""
-             the following pattern will never match:
+             where "a" was given the types:
 
-                 [_ | _] = x
+                 # type: dynamic(:foo)
+                 # from: types_test.ex:LINE
+                 a = :foo
+
+                 # type: dynamic(:bar)
+                 # from: types_test.ex:LINE
+                 a = b
+             """
 
-             because the right-hand side has type:
+      assert typeerror!([{x, _} = {y, _}, x = :foo, y = :bar], {x, y}) == ~l"""
+             this match will never succeed due to incompatible types:
 
-                 dynamic({:ok, term()})
+                 {x, _} = {y, _}
 
              where "x" was given the type:
 
-                 # type: dynamic({:ok, term()})
+                 # type: dynamic(:foo)
+                 # from: types_test.ex:LINE
+                 x = :foo
+
+             where "y" was given the type:
+
+                 # type: dynamic(:bar)
                  # from: types_test.ex:LINE
-                 x = {:ok, _}
+                 y = :bar
              """
     end
   end