Fix regression

Author: josevalim

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

@@ -556,7 +556,7 @@ defmodule Module.Types.Pattern do
     root = %{root: {:var, version}, expr: match}
 
     {precise?, static, dynamic, context} =
-      Enum.reduce(matches, {precise?, [], [], context}, fn
+      Enum.reduce(matches, {precise?, [], [{:var, version}], context}, fn
         pattern, {precise?, static, dynamic, context} ->
           {type, pattern_precise?, context} = of_pattern(pattern, [root], stack, context)
           precise? = precise? and pattern_precise?
@@ -569,18 +569,14 @@ defmodule Module.Types.Pattern do
       end)
 
     return =
-      cond do
-        dynamic == [] -> Enum.reduce(static, &intersection/2)
-        static == [] -> {:intersection, dynamic}
-        true -> {:intersection, [Enum.reduce(static, &intersection/2) | dynamic]}
+      if static == [] do
+        {:intersection, dynamic}
+      else
+        {:intersection, [Enum.reduce(static, &intersection/2) | dynamic]}
       end
 
-    if dynamic == [] do
-      {return, precise?, context}
-    else
-      context = of_var(var, version, [%{root: return, expr: match}], context)
-      {return, precise?, context}
-    end
+    context = of_var(var, version, [%{root: return, expr: match}], context)
+    {return, precise?, context}
   end
 
   # %Struct{...}

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

@@ -1673,6 +1673,15 @@ defmodule Module.Types.ExprTest do
                    tuple([atom([:bitstring]), bitstring_no_binary()])
                  )
                )
+
+      assert typecheck!(
+               [condition],
+               case condition do
+                 x = %{} when x != %{} -> :non_empty_map
+                 %{} -> :maybe_empty_map
+               end
+             ) ==
+               atom([:non_empty_map, :maybe_empty_map])
     end
 
     test "reports error from redundant clauses" do

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

@@ -129,19 +129,15 @@ defmodule Module.Types.PatternTest do
              """
 
       assert typeerror!([a = b, a = :foo, b = :bar], {a, b}) == ~l"""
-             incompatible types assigned to "a":
+             the following pattern will never match:
 
-                 dynamic(:foo) !~ dynamic(:bar)
+                 a = b
 
-             where "a" was given the types:
-
-                 # type: dynamic(:foo)
-                 # from: types_test.ex:LINE
-                 a = :foo
+             where "b" was given the type:
 
                  # type: dynamic(:bar)
                  # from: types_test.ex:LINE
-                 a = b
+                 b = :bar
              """
 
       assert typeerror!([{x, _} = {y, _}, x = :foo, y = :bar], {x, y}) == ~l"""
@@ -910,6 +906,9 @@ defmodule Module.Types.PatternTest do
       assert typecheck!([x], x !== [], x) == dynamic(negation(empty_list()))
       assert typecheck!([x], not (x != []), x) == dynamic(empty_list())
       assert typecheck!([x], not (x !== []), x) == dynamic(empty_list())
+
+      assert typecheck!([x], x != %{}, x) == dynamic(negation(empty_map()))
+      assert typecheck!([x = %{}], x != %{}, x) == dynamic(difference(open_map(), empty_map()))
     end
 
     test "with singleton literals and composite types" do