Tests

Author: josevalim

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

@@ -115,9 +115,20 @@ defmodule Module.Types.Expr do
 
   # %{map | ...}
   # TODO: Once we support typed structs, we need to type check them here.
-  def of_expr({:%{}, _, [{:|, _, [map, args]}]}, stack, context) do
+  def of_expr({:%{}, meta, [{:|, _, [map, args]}]} = expr, stack, context) do
     {map_type, context} = of_expr(map, stack, context)
-    Of.update_map(map_type, args, stack, context, &of_expr/3)
+
+    Of.permutate_map(args, stack, context, &of_expr/3, fn _closed?, pairs ->
+      # TODO: If closed? is false, we need to open up the map
+      Enum.reduce(pairs, map_type, fn {key, type}, acc ->
+        case map_put(acc, key, type) do
+          descr when is_descr(descr) -> descr
+          :badmap -> throw({:badmap, map_type, expr, context})
+        end
+      end)
+    end)
+  catch
+    error -> {error_type(), error(__MODULE__, error, meta, stack, context)}
   end
 
   # %Struct{map | ...}
@@ -134,7 +145,7 @@ defmodule Module.Types.Expr do
     {map_type, context} = of_expr(map, stack, context)
 
     if disjoint?(struct_type, map_type) do
-      warning = {:badupdate, :struct, expr, struct_type, map_type, context}
+      warning = {:badstruct, expr, struct_type, map_type, context}
       {error_type(), error(__MODULE__, warning, update_meta, stack, context)}
     else
       map_type = map_put!(map_type, :__struct__, atom([module]))
@@ -500,15 +511,15 @@ defmodule Module.Types.Expr do
 
   ## Warning formatting
 
-  def format_diagnostic({:badupdate, type, expr, expected_type, actual_type, context}) do
+  def format_diagnostic({:badstruct, expr, expected_type, actual_type, context}) do
     traces = collect_traces(expr, context)
 
     %{
       details: %{typing_traces: traces},
       message:
         IO.iodata_to_binary([
           """
-          incompatible types in #{type} update:
+          incompatible types in struct update:
 
               #{expr_to_string(expr) |> indent(4)}
 
@@ -525,6 +536,27 @@ defmodule Module.Types.Expr do
     }
   end
 
+  def format_diagnostic({:badmap, type, expr, context}) do
+    traces = collect_traces(expr, context)
+
+    %{
+      details: %{typing_traces: traces},
+      message:
+        IO.iodata_to_binary([
+          """
+          expected a map within map update syntax:
+
+              #{expr_to_string(expr) |> indent(4)}
+
+          but got type:
+
+              #{to_quoted_string(type) |> indent(4)}
+          """,
+          format_traces(traces)
+        ])
+    }
+  end
+
   def format_diagnostic({:badbinary, type, expr, context}) do
     traces = collect_traces(expr, context)
 

lib/elixir/lib/module/types/of.ex

@@ -108,26 +108,15 @@ defmodule Module.Types.Of do
   Builds a closed map.
   """
   def closed_map(pairs, stack, context, of_fun) do
-    key_permutations(pairs, stack, context, of_fun, fn closed?, pairs ->
+    permutate_map(pairs, stack, context, of_fun, fn closed?, pairs ->
       if closed?, do: closed_map(pairs), else: open_map(pairs)
     end)
   end
 
   @doc """
-  Updates a map with the given keys.
+  Builds permutation of maps according to the given keys.
   """
-  def update_map(map_type, pairs, stack, context, of_fun) do
-    key_permutations(pairs, stack, context, of_fun, fn _closed?, pairs ->
-      Enum.reduce(pairs, map_type, fn {key, type}, acc ->
-        case map_put(acc, key, type) do
-          descr when is_descr(descr) -> descr
-          error -> throw({error, key, type})
-        end
-      end)
-    end)
-  end
-
-  defp key_permutations(pairs, stack, context, of_fun, of_map) do
+  def permutate_map(pairs, stack, context, of_fun, of_map) do
     {closed?, single, multiple, context} =
       Enum.reduce(pairs, {true, [], [], context}, fn
         {key, value}, {closed?, single, multiple, context} ->

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

@@ -470,6 +470,30 @@ defmodule Module.Types.ExprTest do
                )
     end
 
+    test "updating maps" do
+      assert typecheck!([x], %{x | x: :zero}) ==
+               dynamic(open_map(x: atom([:zero])))
+
+      assert typecheck!([x], %{%{x | x: :zero} | y: :one}) ==
+               dynamic(open_map(x: atom([:zero]), y: atom([:one])))
+
+      assert typeerror!([x = :foo], %{x | x: :zero}) == ~l"""
+             expected a map within map update syntax:
+
+                 %{x | x: :zero}
+
+             but got type:
+
+                 dynamic(:foo)
+
+             where "x" was given the type:
+
+                 # type: dynamic(:foo)
+                 # from: types_test.ex:LINE
+                 x = :foo
+             """
+    end
+
     test "updating structs" do
       assert typecheck!([x], %Point{x | x: :zero}) ==
                dynamic(open_map(__struct__: atom([Point]), x: atom([:zero])))