All green

Author: josevalim

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

@@ -185,12 +185,15 @@ defmodule Module.Types.Pattern do
           {version, context}
         end)
 
-      try do
-        {types, of_pattern_var_deps(changed, vars_paths, vars_deps, tag, stack, context)}
-      catch
-        {:error, context} -> {types, error_vars(pattern_info, context)}
-      end
+      context =
+        Enum.reduce(changed, context, fn version, context ->
+          {_, context} = of_pattern_var_dep(vars_paths, version, tag, stack, context)
+          context
+        end)
+
+      {types, of_pattern_var_deps(changed, vars_paths, vars_deps, tag, stack, context)}
     catch
+      {:error, context} -> {types, error_vars(pattern_info, context)}
       {types, context} -> {types, error_vars(pattern_info, context)}
     end
   end
@@ -201,52 +204,55 @@ defmodule Module.Types.Pattern do
 
   defp of_pattern_var_deps(previous_changed, vars_paths, vars_deps, tag, stack, context) do
     {changed, context} =
-      Enum.reduce(previous_changed, {[], context}, fn version, {changed, context} ->
-        paths = Map.get(vars_paths, version, [])
-
-        {var_changed?, context} =
-          Enum.reduce(paths, {false, context}, fn
-            %{var: var, expr: expr, root: root, path: path}, {var_changed?, context} ->
-              index = 0
-              actual = of_pattern_tree(root, context)
-
-              case of_pattern_var(path, actual, context) do
-                {:ok, type} ->
-                  # Optimization: if current type is already a subtype, there is nothing to refine.
-                  with %{^version => %{type: current_type}} <- context.vars,
-                       true <- subtype?(current_type, type) do
-                    {var_changed?, context}
-                  else
-                    _ ->
-                      case Of.refine_head_var(var, type, expr, stack, context) do
-                        {:ok, _type, context} ->
-                          {true, context}
-
-                        {:error, old_type, context} ->
-                          throw({:error, refine_error(var, old_type, type, stack, context)})
-                      end
-                  end
-
-                :error ->
-                  throw({:error, badpattern_error(expr, index, tag, stack, context)})
-              end
-          end)
+      previous_changed
+      |> Enum.reduce(%{}, fn version, acc ->
+        case vars_deps do
+          %{^version => deps} -> Map.merge(acc, deps)
+          %{} -> acc
+        end
+      end)
+      |> Map.keys()
+      |> Enum.reduce({[], context}, fn version, {changed, context} ->
+        {var_changed?, context} = of_pattern_var_dep(vars_paths, version, tag, stack, context)
 
         case var_changed? do
           false -> {changed, context}
           true -> {[version | changed], context}
         end
       end)
 
-    changed
-    |> Enum.reduce(%{}, fn version, acc ->
-      case vars_deps do
-        %{^version => deps} -> Map.merge(acc, deps)
-        %{} -> acc
-      end
+    of_pattern_var_deps(changed, vars_paths, vars_deps, tag, stack, context)
+  end
+
+  defp of_pattern_var_dep(vars_paths, version, tag, stack, context) do
+    paths = Map.get(vars_paths, version, [])
+
+    Enum.reduce(paths, {false, context}, fn
+      %{var: var, expr: expr, root: root, path: path}, {var_changed?, context} ->
+        index = 0
+        actual = of_pattern_tree(root, context)
+
+        case of_pattern_var(path, actual, context) do
+          {:ok, type} ->
+            # Optimization: if current type is already a subtype, there is nothing to refine.
+            with %{^version => %{type: current_type}} <- context.vars,
+                 true <- subtype?(current_type, type) do
+              {var_changed?, context}
+            else
+              _ ->
+                case Of.refine_head_var(var, type, expr, stack, context) do
+                  {:ok, _type, context} ->
+                    {true, context}
+
+                  {:error, old_type, context} ->
+                    throw({:error, refine_error(var, old_type, type, stack, context)})
+                end
+            end
+
+          :error ->
+            throw({:error, badpattern_error(expr, index, tag, stack, context)})
+        end
     end)
-    |> Map.keys()
-    |> of_pattern_var_deps(vars_paths, vars_deps, tag, stack, context)
   end
 
   defp error_vars({args_paths, vars_paths, _vars_deps}, context) do
@@ -431,7 +437,7 @@ defmodule Module.Types.Pattern do
     {match, version, var} =
       match
       |> unpack_match([])
-      |> Enum.split_while(&(not is_var(&1)))
+      |> Enum.split_while(&(not is_versioned_var(&1)))
       |> case do
         {match, []} ->
           version = make_ref()
@@ -575,6 +581,11 @@ defmodule Module.Types.Pattern do
     {{:var, version}, context}
   end
 
+  defp is_versioned_var({name, _meta, ctx}) when is_atom(name) and is_atom(ctx) and name != :_,
+    do: true
+
+  defp is_versioned_var(_), do: false
+
   defp of_var(var, version, reverse_path, context) do
     {args_paths, vars_paths, vars_deps} = context.pattern_info
     [%{root: root, expr: expr} | path] = Enum.reverse(reverse_path)

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

@@ -52,22 +52,21 @@ 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":
+      assert typeerror!([a = b, a = :foo, b = :bar], {a, b}) == ~l"""
+             incompatible types assigned to "a":
 
-                   dynamic(:foo) !~ dynamic(:bar)
+                 dynamic(:foo) !~ dynamic(:bar)
 
-               where "a" was given the types:
+             where "a" was given the types:
 
-                   # type: dynamic(:foo)
-                   # from: types_test.ex:55
-                   a = :foo
+                 # type: dynamic(:foo)
+                 # from: types_test.ex:LINE
+                 a = :foo
 
-                   # type: dynamic(:bar)
-                   # from: types_test.ex:55
-                   a = b
-               """
+                 # type: dynamic(:bar)
+                 # from: types_test.ex:LINE
+                 a = b
+             """
     end
 
     test "can be accessed even if they don't match" do
@@ -114,13 +113,6 @@ defmodule Module.Types.PatternTest do
              ) == dynamic(tuple([atom([:foo]), integer()]))
     end
 
-    test "parallel match with map" do
-      assert typecheck!(
-               [%{key: value} = context = %{key: %{}}],
-               {context, value}
-             ) == dynamic(tuple([atom([:foo]), integer()]))
-    end
-
     test "reports incompatible types" do
       assert typeerror!([x = {:ok, _} = {:error, _, _}], x) == ~l"""
              the following pattern will never match: