Do not recursively traverse vars to simplify checker, closes #12149

Author: josevalim

lib/elixir/lib/module/types/expr.ex

@@ -153,14 +153,18 @@ defmodule Module.Types.Expr do
          args_type = {:map, dynamic_value_pairs ++ [{:optional, :dynamic, :dynamic}]},
          {:ok, type, context} <- unify(map_type, args_type, stack, context) do
       # Retrieve map type and overwrite with the new value types from the map update
-      {:map, pairs} = resolve_var(type, context)
+      case resolve_var(type, context) do
+        {:map, pairs} ->
+          updated_pairs =
+            Enum.reduce(arg_pairs, pairs, fn {:required, key, value}, pairs ->
+              List.keyreplace(pairs, key, 1, {:required, key, value})
+            end)
 
-      updated_pairs =
-        Enum.reduce(arg_pairs, pairs, fn {:required, key, value}, pairs ->
-          List.keyreplace(pairs, key, 1, {:required, key, value})
-        end)
+          {:ok, {:map, updated_pairs}, context}
 
-      {:ok, {:map, updated_pairs}, context}
+        _ ->
+          {:ok, :dynamic, context}
+      end
     end
   end
 

lib/elixir/lib/module/types/unify.ex

@@ -128,35 +128,10 @@ defmodule Module.Types.Unify do
           {:ok, {:var, var}, context}
         end
 
-      %{^var => {:var, new_var} = var_type} ->
-        unify_result =
-          cond do
-            recursive_type?(var_type, [], context) ->
-              {:ok, var_type, put_in(context.types[var], var_type)}
-
-            var_source? ->
-              unify(var_type, type, stack, context)
-
-            true ->
-              unify(type, var_type, stack, context)
-          end
-
-        case unify_result do
-          {:ok, type, context} ->
-            {:ok, type, context}
-
-          {:error, {type, reason, %{traces: error_traces} = error_context}} ->
-            old_var_traces = Map.get(context.traces, new_var, [])
-            new_var_traces = Map.get(error_traces, new_var, [])
-            add_var_traces = Enum.drop(new_var_traces, -length(old_var_traces))
-
-            error_traces =
-              error_traces
-              |> Map.update(var, add_var_traces, &(add_var_traces ++ &1))
-              |> Map.put(new_var, old_var_traces)
-
-            {:error, {type, reason, %{error_context | traces: error_traces}}}
-        end
+      %{^var => {:var, _} = var_type} ->
+        # Do not recursively traverse type vars for now
+        # to avoid pathological cases related to performance.
+        {:ok, var_type, context}
 
       %{^var => var_type} ->
         # Only add trace if the variable wasn't already "expanded"
@@ -384,11 +359,11 @@ defmodule Module.Types.Unify do
   end
 
   @doc """
-  Resolves a variable raising if it is unbound.
+  Maybe resolves a variable.
   """
   def resolve_var({:var, var}, context) do
     case context.types do
-      %{^var => :unbound} -> raise "cannot resolve unbound var"
+      %{^var => :unbound} -> {:var, var}
       %{^var => type} -> resolve_var(type, context)
     end
   end

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

@@ -222,7 +222,6 @@ defmodule Module.Types.PatternTest do
 
       assert quoted_pattern(x = y = 123) == {:ok, :integer}
       assert quoted_pattern(x = 123 = y) == {:ok, :integer}
-      assert quoted_pattern(123 = x = y) == {:ok, :integer}
 
       assert {:error, {:unable_unify, {{:tuple, 1, [var: 0]}, {:var, 0}, _}}} =
                quoted_pattern({x} = x)
@@ -296,15 +295,6 @@ defmodule Module.Types.PatternTest do
 
       assert quoted_head([x], [is_atom(x) > :foo]) == {:ok, [var: 0]}
 
-      assert quoted_head([x, x = y, y = z], [is_atom(x)]) ==
-               {:ok, [:atom, :atom, :atom]}
-
-      assert quoted_head([x = y, y, y = z], [is_atom(y)]) ==
-               {:ok, [:atom, :atom, :atom]}
-
-      assert quoted_head([x = y, y = z, z], [is_atom(z)]) ==
-               {:ok, [:atom, :atom, :atom]}
-
       assert quoted_head([x, y], [is_atom(x) or is_integer(y)]) ==
                {:ok, [{:var, 0}, {:var, 1}]}
 
@@ -320,15 +310,6 @@ defmodule Module.Types.PatternTest do
       assert quoted_head([x, y], [is_atom(y) or is_integer(y)]) ==
                {:ok, [{:var, 0}, {:union, [:atom, :integer]}]}
 
-      assert quoted_head([x = y], [is_atom(y) or is_integer(y)]) ==
-               {:ok, [{:union, [:atom, :integer]}]}
-
-      assert quoted_head([x = y], [is_atom(x) or is_integer(x)]) ==
-               {:ok, [{:union, [:atom, :integer]}]}
-
-      assert quoted_head([x = y], [is_atom(x) or is_integer(x)]) ==
-               {:ok, [{:union, [:atom, :integer]}]}
-
       assert quoted_head([x], [true == false or is_integer(x)]) ==
                {:ok, [var: 0]}
 

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

@@ -187,36 +187,6 @@ defmodule Module.Types.TypesTest do
              """
     end
 
-    test "warns on guards with multiple variables" do
-      string = warning([x = y], [is_integer(x) and is_binary(y)], {x, y})
-
-      assert string == """
-             incompatible types:
-
-                 integer() !~ binary()
-
-             in expression:
-
-                 # types_test.ex:1
-                 is_binary(y)
-
-             where "x" was given the same type as "y" in:
-
-                 # types_test.ex:1
-                 x = y
-
-             where "y" was given the type integer() in:
-
-                 # types_test.ex:1
-                 is_integer(x)
-
-             where "y" was given the type binary() in:
-
-                 # types_test.ex:1
-                 is_binary(y)
-             """
-    end
-
     test "warns on guards from cases unless generated" do
       string =
         warning(
@@ -243,36 +213,6 @@ defmodule Module.Types.TypesTest do
       assert string == :none
     end
 
-    test "only show relevant traces in warning" do
-      string = warning([x = y, z], [is_integer(x) and is_binary(y) and is_boolean(z)], {x, y, z})
-
-      assert string == """
-             incompatible types:
-
-                 integer() !~ binary()
-
-             in expression:
-
-                 # types_test.ex:1
-                 is_binary(y)
-
-             where "x" was given the same type as "y" in:
-
-                 # types_test.ex:1
-                 x = y
-
-             where "y" was given the type integer() in:
-
-                 # types_test.ex:1
-                 is_integer(x)
-
-             where "y" was given the type binary() in:
-
-                 # types_test.ex:1
-                 is_binary(y)
-             """
-    end
-
     test "check body" do
       string = warning([x], [is_integer(x)], :foo = x)