Start typing map and struct updates

Author: josevalim

lib/elixir/lib/module/types/descr.ex

@@ -1214,7 +1214,7 @@ defmodule Module.Types.Descr do
         end
 
       %{map: map} ->
-        map_get(map, key) |> pop_optional_static()
+        map_fetch_dnf(map, key) |> pop_optional_static()
 
       %{} ->
         {false, none()}
@@ -1239,22 +1239,22 @@ defmodule Module.Types.Descr do
     case :maps.take(:dynamic, descr) do
       :error ->
         if map_only?(descr) do
-          map_put_static_descr(descr, key, type)
+          map_put_static_shared(descr, key, type)
         else
           :badmap
         end
 
       {dynamic, static} when static == @none ->
         if descr_key?(dynamic, :map) do
-          dynamic(map_put_static_descr(dynamic, key, type))
+          dynamic(map_put_static_shared(dynamic, key, type))
         else
           :badmap
         end
 
       {dynamic, static} ->
         if descr_key?(dynamic, :map) and map_only?(static) do
-          dynamic = map_put_static_descr(dynamic, key, type)
-          static = map_put_static_descr(static, key, type)
+          dynamic = map_put_static_shared(dynamic, key, type)
+          static = map_put_static_shared(static, key, type)
           union(dynamic(dynamic), static)
         else
           :badmap
@@ -1263,7 +1263,7 @@ defmodule Module.Types.Descr do
   end
 
   # Directly inserts a key of a given type into every positive and negative map
-  defp map_put_static_descr(descr, key, type) do
+  defp map_put_static_shared(descr, key, type) do
     case map_delete_static(descr, key) do
       %{map: dnf} = descr ->
         dnf =
@@ -1516,7 +1516,7 @@ defmodule Module.Types.Descr do
 
   # Takes a map dnf and returns the union of types it can take for a given key.
   # If the key may be undefined, it will contain the `not_set()` type.
-  defp map_get(dnf, key) do
+  defp map_fetch_dnf(dnf, key) do
     Enum.reduce(dnf, none(), fn
       # Optimization: if there are no negatives,
       # we can return the value directly.

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

@@ -114,38 +114,36 @@ defmodule Module.Types.Expr do
   end
 
   # %{map | ...}
+  # TODO: Once we support typed structs, we need to type check them here.
   def of_expr({:%{}, _, [{:|, _, [map, args]}]}, stack, context) do
-    {_args_type, context} = Of.closed_map(args, stack, context, &of_expr/3)
-    {_map_type, context} = of_expr(map, stack, context)
-    # TODO: intersect map with keys of terms for args
-    # TODO: Merge args_type into map_type with dynamic/static key requirement
-    {dynamic(open_map()), context}
+    {map_type, context} = of_expr(map, stack, context)
+    Of.update_map(map_type, args, stack, context, &of_expr/3)
   end
 
   # %Struct{map | ...}
+  # Note this code, by definition, adds missing struct fields to `map`
+  # because at runtime we do not check for them (only for __struct__ itself).
+  # TODO: Once we support typed structs, we need to type check them here.
   def of_expr(
         {:%, struct_meta, [module, {:%{}, _, [{:|, update_meta, [map, args]}]}]} = expr,
         stack,
         context
       ) do
-    {args_types, context} =
-      Enum.map_reduce(args, context, fn {key, value}, context when is_atom(key) ->
-        {type, context} = of_expr(value, stack, context)
-        {{key, type}, context}
-      end)
-
-    # TODO: args_types could be an empty list
-    {struct_type, context} =
-      Of.struct(module, args_types, :only_defaults, struct_meta, stack, context)
-
+    {info, context} = Of.struct_info(module, struct_meta, stack, context)
+    struct_type = Of.struct_type(module, info)
     {map_type, context} = of_expr(map, stack, context)
 
     if disjoint?(struct_type, map_type) do
       warning = {:badupdate, :struct, expr, struct_type, map_type, context}
       {error_type(), error(__MODULE__, warning, update_meta, stack, context)}
     else
-      # TODO: Merge args_type into map_type with dynamic/static key requirement
-      Of.struct(module, args_types, :merge_defaults, struct_meta, stack, context)
+      map_type = map_put!(map_type, :__struct__, atom([module]))
+
+      Enum.reduce(args, {map_type, context}, fn
+        {key, value}, {map_type, context} when is_atom(key) ->
+          {value_type, context} = of_expr(value, stack, context)
+          {map_put!(map_type, key, value_type), context}
+      end)
     end
   end
 
@@ -155,9 +153,8 @@ defmodule Module.Types.Expr do
   end
 
   # %Struct{}
-  def of_expr({:%, _, [module, {:%{}, _, args}]} = expr, stack, context) do
-    # TODO: We should not skip defaults
-    Of.struct(expr, module, args, :skip_defaults, stack, context, &of_expr/3)
+  def of_expr({:%, meta, [module, {:%{}, _, args}]}, stack, context) do
+    Of.struct_instance(module, args, meta, stack, context, &of_expr/3)
   end
 
   # ()
@@ -357,7 +354,8 @@ defmodule Module.Types.Expr do
         # Exceptions are not validated in the compiler,
         # to avoid export dependencies. So we do it here.
         if Code.ensure_loaded?(exception) and function_exported?(exception, :__struct__, 0) do
-          Of.struct(exception, args, :merge_defaults, meta, stack, context)
+          {info, context} = Of.struct_info(exception, meta, stack, context)
+          {Of.struct_type(exception, info, args), context}
         else
           # If the exception cannot be found or is invalid,
           # we call Of.remote/5 to emit a warning.
@@ -493,6 +491,13 @@ defmodule Module.Types.Expr do
     context
   end
 
+  defp map_put!(map_type, key, value_type) do
+    case map_put(map_type, key, value_type) do
+      descr when is_descr(descr) -> descr
+      error -> raise "unexpected #{inspect(error)}"
+    end
+  end
+
   ## Warning formatting
 
   def format_diagnostic({:badupdate, type, expr, expected_type, actual_type, context}) do

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

@@ -107,9 +107,29 @@ defmodule Module.Types.Of do
   @doc """
   Builds a closed map.
   """
-  def closed_map(pairs, extra \\ [], stack, context, of_fun) do
+  def closed_map(pairs, stack, context, of_fun) do
+    key_permutations(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.
+  """
+  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
     {closed?, single, multiple, context} =
-      Enum.reduce(pairs, {true, extra, [], context}, fn
+      Enum.reduce(pairs, {true, [], [], context}, fn
         {key, value}, {closed?, single, multiple, context} ->
           {keys, context} = of_finite_key_type(key, stack, context, of_fun)
           {value_type, context} = of_fun.(value, stack, context)
@@ -129,13 +149,11 @@ defmodule Module.Types.Of do
     map =
       case Enum.reverse(multiple) do
         [] ->
-          pairs = Enum.reverse(single)
-          if closed?, do: closed_map(pairs), else: open_map(pairs)
+          of_map.(closed?, Enum.reverse(single))
 
         [{keys, type} | tail] ->
           for key <- keys, t <- cartesian_map(tail) do
-            pairs = Enum.reverse(single, [{key, type} | t])
-            if closed?, do: closed_map(pairs), else: open_map(pairs)
+            of_map.(closed?, Enum.reverse(single, [{key, type} | t]))
           end
           |> Enum.reduce(&union/2)
       end
@@ -167,9 +185,9 @@ defmodule Module.Types.Of do
   end
 
   @doc """
-  Handles structs creation.
+  Handles instantiation of a new struct.
   """
-  def struct({:%, meta, _}, struct, args, default_handling, stack, context, of_fun)
+  def struct_instance(struct, args, meta, stack, context, of_fun)
       when is_atom(struct) do
     # The compiler has already checked the keys are atoms and which ones are required.
     {args_types, context} =
@@ -178,27 +196,8 @@ defmodule Module.Types.Of do
         {{key, type}, context}
       end)
 
-    struct(struct, args_types, default_handling, meta, stack, context)
-  end
-
-  @doc """
-  Struct handling assuming the args have already been converted.
-  """
-  # TODO: Allow structs fields to be defined and validate args against the struct types.
-  # TODO: Use the struct default values to define the default types.
-  def struct(struct, args_types, default_handling, meta, stack, context) do
     {info, context} = struct_info(struct, meta, stack, context)
-    term = term()
-    defaults = for %{field: field} <- info, do: {field, term}
-
-    pairs =
-      case default_handling do
-        :merge_defaults -> [{:__struct__, atom([struct])} | defaults] ++ args_types
-        :skip_defaults -> [{:__struct__, atom([struct])} | args_types]
-        :only_defaults -> [{:__struct__, atom([struct])} | defaults]
-      end
-
-    {closed_map(pairs), context}
+    {struct_type(struct, info, args_types), context}
   end
 
   @doc """
@@ -214,6 +213,17 @@ defmodule Module.Types.Of do
     {info, context}
   end
 
+  @doc """
+  Builds a type from the struct info.
+  """
+  def struct_type(struct, info, args_types \\ []) do
+    term = term()
+    pairs = for %{field: field} <- info, do: {field, term}
+    pairs = [{:__struct__, atom([struct])} | pairs]
+    pairs = if args_types == [], do: pairs, else: pairs ++ args_types
+    closed_map(pairs)
+  end
+
   ## Binary
 
   @doc """

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

@@ -657,10 +657,10 @@ defmodule Module.Types.Pattern do
   end
 
   # %Struct{...}
-  def of_guard({:%, _, [module, {:%{}, _, args}]} = struct, _expected, _expr, stack, context)
+  def of_guard({:%, meta, [module, {:%{}, _, args}]} = struct, _expected, _expr, stack, context)
       when is_atom(module) do
     fun = &of_guard(&1, dynamic(), struct, &2, &3)
-    Of.struct(struct, module, args, :skip_defaults, stack, context, fun)
+    Of.struct_instance(module, args, meta, stack, context, fun)
   end
 
   # %{...}

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

@@ -472,9 +472,17 @@ defmodule Module.Types.ExprTest do
 
     test "updating structs" do
       assert typecheck!([x], %Point{x | x: :zero}) ==
-               closed_map(__struct__: atom([Point]), x: atom([:zero]), y: term(), z: term())
+               dynamic(open_map(__struct__: atom([Point]), x: atom([:zero])))
 
-      assert typeerror!([x = :foo], %Point{x | x: :zero}) ==
+      assert typecheck!([x], %Point{%Point{x | x: :zero} | y: :one}) ==
+               dynamic(open_map(__struct__: atom([Point]), x: atom([:zero]), y: atom([:one])))
+
+      assert typeerror!(
+               (
+                 x = %{x: 0}
+                 %Point{x | x: :zero}
+               )
+             ) ==
                ~l"""
                incompatible types in struct update:
 
@@ -486,13 +494,13 @@ defmodule Module.Types.ExprTest do
 
                but got type:
 
-                   dynamic(:foo)
+                   %{x: integer()}
 
                where "x" was given the type:
 
-                   # type: dynamic(:foo)
-                   # from: types_test.ex:LINE-1
-                   x = :foo
+                   # type: %{x: integer()}
+                   # from: types_test.ex:LINE-4
+                   x = %{x: 0}
                """
     end